rumale-evaluation_measure 0.24.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: d22a96529d4ce3e701d769258ce6de524d06b9716405a9300a0675bcddd28409
+  data.tar.gz: bf7f2f49863313143016aeb0a1b596a1d2bfb405dd3803e0a8fe17d134086896
+SHA512:
+  metadata.gz: 63634dc026752d51849ba6bd64f40c92dd2ae396565cbd183d39c7713b5c3243bbc8b5a2329d013927fbb1de6e542f5fe9cc6889cfcc1fb64260d11a6bc5284f
+  data.tar.gz: 59a9cd733f2d49e1db27443a1d80950f16d073af611e2c3efc39e7842d13240a7105b37136317a7a81adf3445c52f4e8cbada0e3db5ea3c0366995c3c1c5e958

data/LICENSE.txt

@@ -0,0 +1,27 @@
+Copyright (c) 2022 Atsushi Tatsuma
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+* Redistributions of source code must retain the above copyright notice, this
+  list of conditions and the following disclaimer.
+
+* Redistributions in binary form must reproduce the above copyright notice,
+  this list of conditions and the following disclaimer in the documentation
+  and/or other materials provided with the distribution.
+
+* Neither the name of the copyright holder nor the names of its
+  contributors may be used to endorse or promote products derived from
+  this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

data/README.md

@@ -0,0 +1,34 @@
+# Rumale::EvaluationMeasure
+
+[![Gem Version](https://badge.fury.io/rb/rumale-evaluation_measure.svg)](https://badge.fury.io/rb/rumale-evaluation_measure)
+[![BSD 3-Clause License](https://img.shields.io/badge/License-BSD%203--Clause-orange.svg)](https://github.com/yoshoku/rumale/blob/main/rumale-evaluation_measure/LICENSE.txt)
+[![Documentation](https://img.shields.io/badge/api-reference-blue.svg)](https://yoshoku.github.io/rumale/doc/Rumale/EvaluationMeasure.html)
+
+Rumale is a machine learning library in Ruby.
+Rumale::EvaluationMeasure provides evaluation measures,
+such as accuracy, precision, recall, and f-score,
+with Rumale interface.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'rumale-evaluation_measure'
+```
+
+And then execute:
+
+    $ bundle install
+
+Or install it yourself as:
+
+    $ gem install rumale-evaluation_measure
+
+## Documentation
+
+- [Rumale API Documentation - EvaluationMeasure](https://yoshoku.github.io/rumale/doc/Rumale/EvaluationMeasure.html)
+
+## License
+
+The gem is available as open source under the terms of the [BSD-3-Clause License](https://opensource.org/licenses/BSD-3-Clause).

data/lib/rumale/evaluation_measure/accuracy.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require 'rumale/base/evaluator'
+
+module Rumale
+  module EvaluationMeasure
+    # Accuracy is a class that calculates the accuracy of classifier from the predicted labels.
+    #
+    # @example
+    #   require 'rumale/evaluation_measure/accuracy'
+    #
+    #   evaluator = Rumale::EvaluationMeasure::Accuracy.new
+    #   puts evaluator.score(ground_truth, predicted)
+    class Accuracy
+      include ::Rumale::Base::Evaluator
+
+      # Calculate mean accuracy.
+      #
+      # @param y_true [Numo::Int32] (shape: [n_samples]) Ground truth labels.
+      # @param y_pred [Numo::Int32] (shape: [n_samples]) Predicted labels.
+      # @return [Float] Mean accuracy
+      def score(y_true, y_pred)
+        (y_true.to_a.map.with_index { |label, n| label == y_pred[n] ? 1 : 0 }).sum / y_true.size.to_f
+      end
+    end
+  end
+end

data/lib/rumale/evaluation_measure/adjusted_rand_score.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+require 'rumale/base/evaluator'
+
+module Rumale
+  module EvaluationMeasure
+    # AdjustedRandScore is a class that calculates the adjusted rand index.
+    #
+    # @example
+    #   require 'rumale/evaluation_measure/adjusted_rand_score'
+    #
+    #   evaluator = Rumale::EvaluationMeasure::AdjustedRandScore.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 Learnig Research, Vol. 11, pp.2837--2854, 2010.
+    class AdjustedRandScore
+      include ::Rumale::Base::Evaluator
+
+      # Calculate adjusted rand index.
+      #
+      # @param y_true [Numo::Int32] (shape: [n_samples]) Ground truth labels.
+      # @param y_pred [Numo::Int32] (shape: [n_samples]) Predicted cluster labels.
+      # @return [Float] Adjusted rand index.
+      def score(y_true, y_pred)
+        # initiazlie some variables.
+        n_samples = y_pred.size
+        n_classes = y_true.to_a.uniq.size
+        n_clusters = y_pred.to_a.uniq.size
+
+        # check special cases.
+        return 1.0 if special_cases?(n_samples, n_classes, n_clusters)
+
+        # calculate adjusted rand index.
+        table = contingency_table(y_true, y_pred)
+        sum_comb_a = table.sum(axis: 1).to_a.sum { |v| comb_two(v) }
+        sum_comb_b = table.sum(axis: 0).to_a.sum { |v| comb_two(v) }
+        sum_comb = table.flatten.to_a.sum { |v| comb_two(v) }
+        prod_comb = (sum_comb_a * sum_comb_b).fdiv(comb_two(n_samples))
+        mean_comb = (sum_comb_a + sum_comb_b).fdiv(2)
+        (sum_comb - prod_comb).fdiv(mean_comb - prod_comb)
+      end
+
+      private
+
+      def contingency_table(y_true, y_pred)
+        class_ids = y_true.to_a.uniq
+        cluster_ids = y_pred.to_a.uniq
+        n_classes = class_ids.size
+        n_clusters = cluster_ids.size
+        table = Numo::Int32.zeros(n_classes, n_clusters)
+        n_classes.times do |i|
+          b_true = y_true.eq(class_ids[i])
+          n_clusters.times do |j|
+            b_pred = y_pred.eq(cluster_ids[j])
+            table[i, j] = (b_true & b_pred).count
+          end
+        end
+        table
+      end
+
+      def special_cases?(n_samples, n_classes, n_clusters)
+        ((n_classes.zero? && n_clusters.zero?) ||
+         (n_classes == 1 && n_clusters == 1) ||
+         (n_classes == n_samples && n_clusters == n_samples))
+      end
+
+      def comb_two(k)
+        k * (k - 1) / 2
+      end
+    end
+  end
+end

data/lib/rumale/evaluation_measure/calinski_harabasz_score.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+require 'rumale/base/evaluator'
+
+module Rumale
+  module EvaluationMeasure
+    # CalinskiHarabaszScore is a class that calculates the Calinski and Harabasz score.
+    #
+    # @example
+    #   require 'rumale/evaluation_measure/calinski_harabasz_score'
+    #
+    #   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 ::Rumale::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)
+        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

@@ -0,0 +1,47 @@
+# 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
+    #   require 'rumale/evaluation_measure/davies_bouldin_score'
+    #
+    #   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
+      # 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)
+        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)
+        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

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require 'rumale/base/evaluator'
+
+module Rumale
+  module EvaluationMeasure
+    # ExplainedVarianceScore is a class that calculates the explained variance score.
+    #
+    # @example
+    #   require 'rumale/evaluation_measure/explained_variance_score'
+    #
+    #   evaluator = Rumale::EvaluationMeasure::ExplainedVarianceScore.new
+    #   puts evaluator.score(ground_truth, predicted)
+    class ExplainedVarianceScore
+      include ::Rumale::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)
+        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

@@ -0,0 +1,48 @@
+# 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
+    #   require 'rumale/evaluation_measure/f_score'
+    #
+    #   evaluator = Rumale::EvaluationMeasure::FScore.new
+    #   puts evaluator.score(ground_truth, predicted)
+    class FScore
+      include ::Rumale::Base::Evaluator
+      include ::Rumale::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')
+        @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)
+        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

@@ -0,0 +1,143 @@
+# frozen_string_literal: true
+
+require 'numo/narray'
+
+require 'rumale/evaluation_measure/accuracy'
+require 'rumale/evaluation_measure/precision_recall'
+
+module Rumale
+  # This module consists of the classes for model evaluation.
+  module EvaluationMeasure
+    module_function
+
+    # Calculate confusion matrix for evaluating classification performance.
+    #
+    # @example
+    #   require 'rumale/evaluation_measure/function'
+    #
+    #   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)
+      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
+
+    # 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) # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
+      # 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
+  end
+end

data/lib/rumale/evaluation_measure/log_loss.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+require 'rumale/base/evaluator'
+
+module Rumale
+  module EvaluationMeasure
+    # LogLoss is a class that calculates the logarithmic loss of predicted class probability.
+    #
+    # @example
+    #   require 'rumale/evaluation_measure/log_loss'
+    #
+    #   evaluator = Rumale::EvaluationMeasure::LogLoss.new
+    #   puts evaluator.score(ground_truth, predicted)
+    class LogLoss
+      include ::Rumale::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)
+        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
+                     binarized_y_true = binarize(y_true)
+                     clipped_p /= clipped_p.sum(axis: 1).expand_dims(1)
+                     -(binarized_y_true * Numo::NMath.log(clipped_p)).sum(axis: 1)
+                   end
+        log_loss.sum / n_samples
+      end
+
+      private
+
+      def binarize(y)
+        classes = y.to_a.uniq.sort
+        n_samples = y.size
+        n_classes = classes.size
+        binarized = Numo::DFloat.zeros(n_samples, n_classes)
+        n_samples.times { |n| binarized[n, classes.index(y[n])] = 1 }
+        binarized
+      end
+    end
+  end
+end

data/lib/rumale/evaluation_measure/mean_absolute_error.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require 'rumale/base/evaluator'
+
+module Rumale
+  module EvaluationMeasure
+    # MeanAbsoluteError is a class that calculates the mean absolute error.
+    #
+    # @example
+    #   require 'rumale/evaluation_measure/mean_absolute_error'
+    #
+    #   evaluator = Rumale::EvaluationMeasure::MeanAbsoluteError.new
+    #   puts evaluator.score(ground_truth, predicted)
+    class MeanAbsoluteError
+      include ::Rumale::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 - y_pred).abs.mean
+      end
+    end
+  end
+end

data/lib/rumale/evaluation_measure/mean_squared_error.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require 'rumale/base/evaluator'
+
+module Rumale
+  module EvaluationMeasure
+    # MeanSquaredError is a class that calculates the mean squared error.
+    #
+    # @example
+    #   require 'rumale/evaluation_measure/mean_squared_error'
+    #
+    #   evaluator = Rumale::EvaluationMeasure::MeanSquaredError.new
+    #   puts evaluator.score(ground_truth, predicted)
+    class MeanSquaredError
+      include ::Rumale::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 - y_pred)**2).mean
+      end
+    end
+  end
+end

data/lib/rumale/evaluation_measure/mean_squared_log_error.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require 'rumale/base/evaluator'
+
+module Rumale
+  module EvaluationMeasure
+    # MeanSquaredLogError is a class that calculates the mean squared logarithmic error.
+    #
+    # @example
+    #   require 'rumale/evaluation_measure/mean_squared_log_error'
+    #
+    #   evaluator = Rumale::EvaluationMeasure::MeanSquaredLogError.new
+    #   puts evaluator.score(ground_truth, predicted)
+    class MeanSquaredLogError
+      include ::Rumale::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)
+        ((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

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require 'rumale/base/evaluator'
+
+module Rumale
+  module EvaluationMeasure
+    # MedianAbsoluteError is a class that calculates the median absolute error.
+    #
+    # @example
+    #   require 'rumale/evaluation_measure/median_absolute_error'
+    #
+    #   evaluator = Rumale::EvaluationMeasure::MedianAbsoluteError.new
+    #   puts evaluator.score(ground_truth, predicted)
+    class MedianAbsoluteError
+      include ::Rumale::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 - y_pred).abs.median
+      end
+    end
+  end
+end