rumale 0.23.3 → 0.24.0

data/lib/rumale/naive_bayes/base_naive_bayes.rb

@@ -1,47 +0,0 @@
-# frozen_string_literal: true
-
-require 'rumale/base/base_estimator'
-require 'rumale/base/classifier'
-
-module Rumale
-  # This module consists of the classes that implement naive bayes models.
-  module NaiveBayes
-    # BaseNaiveBayes is a class that has methods for common processes of naive bayes classifier.
-    # This class is used internally.
-    class BaseNaiveBayes
-      include Base::BaseEstimator
-      include Base::Classifier
-
-      # Predict class labels for samples.
-      #
-      # @param x [Numo::DFloat] (shape: [n_samples, n_features]) The samples to predict the labels.
-      # @return [Numo::Int32] (shape: [n_samples]) Predicted class label per sample.
-      def predict(x)
-        x = check_convert_sample_array(x)
-        n_samples = x.shape.first
-        decision_values = decision_function(x)
-        Numo::Int32.asarray(Array.new(n_samples) { |n| @classes[decision_values[n, true].max_index] })
-      end
-
-      # Predict log-probability for samples.
-      #
-      # @param x [Numo::DFloat] (shape: [n_samples, n_features]) The samples to predict the log-probailities.
-      # @return [Numo::DFloat] (shape: [n_samples, n_classes]) Predicted log-probability of each class per sample.
-      def predict_log_proba(x)
-        x = check_convert_sample_array(x)
-        n_samples, = x.shape
-        log_likelihoods = decision_function(x)
-        log_likelihoods - Numo::NMath.log(Numo::NMath.exp(log_likelihoods).sum(1)).reshape(n_samples, 1)
-      end
-
-      # Predict probability for samples.
-      #
-      # @param x [Numo::DFloat] (shape: [n_samples, n_features]) The samples to predict the probailities.
-      # @return [Numo::DFloat] (shape: [n_samples, n_classes]) Predicted probability of each class per sample.
-      def predict_proba(x)
-        x = check_convert_sample_array(x)
-        Numo::NMath.exp(predict_log_proba(x)).abs
-      end
-    end
-  end
-end

data/lib/rumale/naive_bayes/bernoulli_nb.rb

@@ -1,82 +0,0 @@
-# frozen_string_literal: true
-
-require 'rumale/naive_bayes/base_naive_bayes'
-
-module Rumale
-  module NaiveBayes
-    # BernoulliNB is a class that implements Bernoulli Naive Bayes classifier.
-    #
-    # @example
-    #   estimator = Rumale::NaiveBayes::BernoulliNB.new(smoothing_param: 1.0, bin_threshold: 0.0)
-    #   estimator.fit(training_samples, training_labels)
-    #   results = estimator.predict(testing_samples)
-    #
-    # *Reference*
-    # - Manning, C D., Raghavan, P., and Schutze, H., "Introduction to Information Retrieval," Cambridge University Press., 2008.
-    class BernoulliNB < BaseNaiveBayes
-      # Return the class labels.
-      # @return [Numo::Int32] (size: n_classes)
-      attr_reader :classes
-
-      # Return the prior probabilities of the classes.
-      # @return [Numo::DFloat] (shape: [n_classes])
-      attr_reader :class_priors
-
-      # Return the conditional probabilities for features of each class.
-      # @return [Numo::DFloat] (shape: [n_classes, n_features])
-      attr_reader :feature_probs
-
-      # Create a new classifier with Bernoulli Naive Bayes.
-      #
-      # @param smoothing_param [Float] The Laplace smoothing parameter.
-      # @param bin_threshold [Float] The threshold for binarizing of features.
-      def initialize(smoothing_param: 1.0, bin_threshold: 0.0)
-        check_params_numeric(smoothing_param: smoothing_param, bin_threshold: bin_threshold)
-        check_params_positive(smoothing_param: smoothing_param)
-        @params = {}
-        @params[:smoothing_param] = smoothing_param
-        @params[:bin_threshold] = bin_threshold
-      end
-
-      # Fit the model with given training data.
-      #
-      # @param x [Numo::DFloat] (shape: [n_samples, n_features]) The training data to be used for fitting the model.
-      # @param y [Numo::Int32] (shape: [n_samples]) The categorical variables (e.g. labels)
-      #   to be used for fitting the model.
-      # @return [BernoulliNB] The learned classifier itself.
-      def fit(x, y)
-        x = check_convert_sample_array(x)
-        y = check_convert_label_array(y)
-        check_sample_label_size(x, y)
-        n_samples, = x.shape
-        bin_x = Numo::DFloat[*x.gt(@params[:bin_threshold])]
-        @classes = Numo::Int32[*y.to_a.uniq.sort]
-        n_samples_each_class = Numo::DFloat[*@classes.to_a.map { |l| y.eq(l).count.to_f }]
-        @class_priors = n_samples_each_class / n_samples
-        count_features = Numo::DFloat[*@classes.to_a.map { |l| bin_x[y.eq(l).where, true].sum(0) }]
-        count_features += @params[:smoothing_param]
-        n_samples_each_class += 2.0 * @params[:smoothing_param]
-        n_classes = @classes.size
-        @feature_probs = count_features / n_samples_each_class.reshape(n_classes, 1)
-        self
-      end
-
-      # Calculate confidence scores for samples.
-      #
-      # @param x [Numo::DFloat] (shape: [n_samples, n_features]) The samples to compute the scores.
-      # @return [Numo::DFloat] (shape: [n_samples, n_classes]) Confidence scores per sample for each class.
-      def decision_function(x)
-        x = check_convert_sample_array(x)
-        n_classes = @classes.size
-        bin_x = Numo::DFloat[*x.gt(@params[:bin_threshold])]
-        not_bin_x = Numo::DFloat[*x.le(@params[:bin_threshold])]
-        log_likelihoods = Array.new(n_classes) do |l|
-          Math.log(@class_priors[l]) + (
-            (Numo::DFloat[*bin_x] * Numo::NMath.log(@feature_probs[l, true])).sum(1)
-            (Numo::DFloat[*not_bin_x] * Numo::NMath.log(1.0 - @feature_probs[l, true])).sum(1))
-        end
-        Numo::DFloat[*log_likelihoods].transpose.dup
-      end
-    end
-  end
-end

data/lib/rumale/naive_bayes/complement_nb.rb

@@ -1,85 +0,0 @@
-# frozen_string_literal: true
-
-require 'rumale/naive_bayes/base_naive_bayes'
-
-module Rumale
-  module NaiveBayes
-    # ComplementNB is a class that implements Complement Naive Bayes classifier.
-    #
-    # @example
-    #   estimator = Rumale::NaiveBayes::ComplementNB.new(smoothing_param: 1.0)
-    #   estimator.fit(training_samples, training_labels)
-    #   results = estimator.predict(testing_samples)
-    #
-    # *Reference*
-    # - Rennie, J. D. M., Shih, L., Teevan, J., and Karger, D. R., "Tackling the Poor Assumptions of Naive Bayes Text Classifiers," ICML' 03, pp. 616--623, 2013.
-    class ComplementNB < BaseNaiveBayes
-      # Return the class labels.
-      # @return [Numo::Int32] (size: n_classes)
-      attr_reader :classes
-
-      # Return the prior probabilities of the classes.
-      # @return [Numo::DFloat] (shape: [n_classes])
-      attr_reader :class_priors
-
-      # Return the conditional probabilities for features of each class.
-      # @return [Numo::DFloat] (shape: [n_classes, n_features])
-      attr_reader :feature_probs
-
-      # Create a new classifier with Complement Naive Bayes.
-      #
-      # @param smoothing_param [Float] The smoothing parameter.
-      # @param norm [Boolean] The flag indicating whether to normlize the weight vectors.
-      def initialize(smoothing_param: 1.0, norm: false)
-        check_params_numeric(smoothing_param: smoothing_param)
-        check_params_positive(smoothing_param: smoothing_param)
-        check_params_boolean(norm: norm)
-        @params = {}
-        @params[:smoothing_param] = smoothing_param
-        @params[:norm] = norm
-      end
-
-      # Fit the model with given training data.
-      #
-      # @param x [Numo::DFloat] (shape: [n_samples, n_features]) The training data to be used for fitting the model.
-      # @param y [Numo::Int32] (shape: [n_samples]) The categorical variables (e.g. labels)
-      #   to be used for fitting the model.
-      # @return [ComplementNB] The learned classifier itself.
-      def fit(x, y)
-        x = check_convert_sample_array(x)
-        y = check_convert_label_array(y)
-        check_sample_label_size(x, y)
-        n_samples, = x.shape
-        @classes = Numo::Int32[*y.to_a.uniq.sort]
-        @class_priors = Numo::DFloat[*@classes.to_a.map { |l| y.eq(l).count.fdiv(n_samples) }]
-        @class_log_probs = Numo::NMath.log(@class_priors)
-        compl_features = Numo::DFloat[*@classes.to_a.map { |l| x[y.ne(l).where, true].sum(0) }]
-        compl_features += @params[:smoothing_param]
-        n_classes = @classes.size
-        @feature_probs = compl_features / compl_features.sum(1).reshape(n_classes, 1)
-        feature_log_probs = Numo::NMath.log(@feature_probs)
-        @weights = if normalize?
-                     feature_log_probs / feature_log_probs.sum(1).reshape(n_classes, 1)
-                   else
-                     -feature_log_probs
-                   end
-        self
-      end
-
-      # Calculate confidence scores for samples.
-      #
-      # @param x [Numo::DFloat] (shape: [n_samples, n_features]) The samples to compute the scores.
-      # @return [Numo::DFloat] (shape: [n_samples, n_classes]) Confidence scores per sample for each class.
-      def decision_function(x)
-        x = check_convert_sample_array(x)
-        @class_log_probs + x.dot(@weights.transpose)
-      end
-
-      private
-
-      def normalize?
-        @params[:norm] == true
-      end
-    end
-  end
-end

data/lib/rumale/naive_bayes/gaussian_nb.rb

@@ -1,69 +0,0 @@
-# frozen_string_literal: true
-
-require 'rumale/naive_bayes/base_naive_bayes'
-
-module Rumale
-  module NaiveBayes
-    # GaussianNB is a class that implements Gaussian Naive Bayes classifier.
-    #
-    # @example
-    #   estimator = Rumale::NaiveBayes::GaussianNB.new
-    #   estimator.fit(training_samples, training_labels)
-    #   results = estimator.predict(testing_samples)
-    class GaussianNB < BaseNaiveBayes
-      # Return the class labels.
-      # @return [Numo::Int32] (size: n_classes)
-      attr_reader :classes
-
-      # Return the prior probabilities of the classes.
-      # @return [Numo::DFloat] (shape: [n_classes])
-      attr_reader :class_priors
-
-      # Return the mean vectors of the classes.
-      # @return [Numo::DFloat] (shape: [n_classes, n_features])
-      attr_reader :means
-
-      # Return the variance vectors of the classes.
-      # @return [Numo::DFloat] (shape: [n_classes, n_features])
-      attr_reader :variances
-
-      # Create a new classifier with Gaussian Naive Bayes.
-      def initialize
-        @params = {}
-      end
-
-      # Fit the model with given training data.
-      #
-      # @param x [Numo::DFloat] (shape: [n_samples, n_features]) The training data to be used for fitting the model.
-      # @param y [Numo::Int32] (shape: [n_samples]) The categorical variables (e.g. labels)
-      #   to be used for fitting the model.
-      # @return [GaussianNB] The learned classifier itself.
-      def fit(x, y)
-        x = check_convert_sample_array(x)
-        y = check_convert_label_array(y)
-        check_sample_label_size(x, y)
-        n_samples, = x.shape
-        @classes = Numo::Int32[*y.to_a.uniq.sort]
-        @class_priors = Numo::DFloat[*@classes.to_a.map { |l| y.eq(l).count / n_samples.to_f }]
-        @means = Numo::DFloat[*@classes.to_a.map { |l| x[y.eq(l).where, true].mean(0) }]
-        @variances = Numo::DFloat[*@classes.to_a.map { |l| x[y.eq(l).where, true].var(0) }]
-        self
-      end
-
-      # Calculate confidence scores for samples.
-      #
-      # @param x [Numo::DFloat] (shape: [n_samples, n_features]) The samples to compute the scores.
-      # @return [Numo::DFloat] (shape: [n_samples, n_classes]) Confidence scores per sample for each class.
-      def decision_function(x)
-        x = check_convert_sample_array(x)
-        n_classes = @classes.size
-        log_likelihoods = Array.new(n_classes) do |l|
-          Math.log(@class_priors[l]) - 0.5 * (
-            Numo::NMath.log(2.0 * Math::PI * @variances[l, true]) +
-            ((x - @means[l, true])**2 / @variances[l, true])).sum(1)
-        end
-        Numo::DFloat[*log_likelihoods].transpose.dup
-      end
-    end
-  end
-end

data/lib/rumale/naive_bayes/multinomial_nb.rb

@@ -1,74 +0,0 @@
-# frozen_string_literal: true
-
-require 'rumale/naive_bayes/base_naive_bayes'
-
-module Rumale
-  module NaiveBayes
-    # MultinomialNB is a class that implements Multinomial Naive Bayes classifier.
-    #
-    # @example
-    #   estimator = Rumale::NaiveBayes::MultinomialNB.new(smoothing_param: 1.0)
-    #   estimator.fit(training_samples, training_labels)
-    #   results = estimator.predict(testing_samples)
-    #
-    # *Reference*
-    # - Manning, C D., Raghavan, P., and Schutze, H., "Introduction to Information Retrieval," Cambridge University Press., 2008.
-    class MultinomialNB < BaseNaiveBayes
-      # Return the class labels.
-      # @return [Numo::Int32] (size: n_classes)
-      attr_reader :classes
-
-      # Return the prior probabilities of the classes.
-      # @return [Numo::DFloat] (shape: [n_classes])
-      attr_reader :class_priors
-
-      # Return the conditional probabilities for features of each class.
-      # @return [Numo::DFloat] (shape: [n_classes, n_features])
-      attr_reader :feature_probs
-
-      # Create a new classifier with Multinomial Naive Bayes.
-      #
-      # @param smoothing_param [Float] The Laplace smoothing parameter.
-      def initialize(smoothing_param: 1.0)
-        check_params_numeric(smoothing_param: smoothing_param)
-        check_params_positive(smoothing_param: smoothing_param)
-        @params = {}
-        @params[:smoothing_param] = smoothing_param
-      end
-
-      # Fit the model with given training data.
-      #
-      # @param x [Numo::DFloat] (shape: [n_samples, n_features]) The training data to be used for fitting the model.
-      # @param y [Numo::Int32] (shape: [n_samples]) The categorical variables (e.g. labels)
-      #   to be used for fitting the model.
-      # @return [MultinomialNB] The learned classifier itself.
-      def fit(x, y)
-        x = check_convert_sample_array(x)
-        y = check_convert_label_array(y)
-        check_sample_label_size(x, y)
-        n_samples, = x.shape
-        @classes = Numo::Int32[*y.to_a.uniq.sort]
-        @class_priors = Numo::DFloat[*@classes.to_a.map { |l| y.eq(l).count / n_samples.to_f }]
-        count_features = Numo::DFloat[*@classes.to_a.map { |l| x[y.eq(l).where, true].sum(0) }]
-        count_features += @params[:smoothing_param]
-        n_classes = @classes.size
-        @feature_probs = count_features / count_features.sum(1).reshape(n_classes, 1)
-        self
-      end
-
-      # Calculate confidence scores for samples.
-      #
-      # @param x [Numo::DFloat] (shape: [n_samples, n_features]) The samples to compute the scores.
-      # @return [Numo::DFloat] (shape: [n_samples, n_classes]) Confidence scores per sample for each class.
-      def decision_function(x)
-        x = check_convert_sample_array(x)
-        n_classes = @classes.size
-        bin_x = x.gt(0)
-        log_likelihoods = Array.new(n_classes) do |l|
-          Math.log(@class_priors[l]) + (Numo::DFloat[*bin_x] * Numo::NMath.log(@feature_probs[l, true])).sum(1)
-        end
-        Numo::DFloat[*log_likelihoods].transpose.dup
-      end
-    end
-  end
-end

data/lib/rumale/naive_bayes/negation_nb.rb

@@ -1,71 +0,0 @@
-# frozen_string_literal: true
-
-require 'rumale/naive_bayes/base_naive_bayes'
-
-module Rumale
-  module NaiveBayes
-    # NegationNB is a class that implements Negation Naive Bayes classifier.
-    #
-    # @example
-    #   estimator = Rumale::NaiveBayes::NegationNB.new(smoothing_param: 1.0)
-    #   estimator.fit(training_samples, training_labels)
-    #   results = estimator.predict(testing_samples)
-    #
-    # *Reference*
-    # - Komiya, K., Sato, N., Fujimoto, K., and Kotani, Y., "Negation Naive Bayes for Categorization of Product Pages on the Web," RANLP' 11, pp. 586--592, 2011.
-    class NegationNB < BaseNaiveBayes
-      # Return the class labels.
-      # @return [Numo::Int32] (size: n_classes)
-      attr_reader :classes
-
-      # Return the prior probabilities of the classes.
-      # @return [Numo::DFloat] (shape: [n_classes])
-      attr_reader :class_priors
-
-      # Return the conditional probabilities for features of each class.
-      # @return [Numo::DFloat] (shape: [n_classes, n_features])
-      attr_reader :feature_probs
-
-      # Create a new classifier with Complement Naive Bayes.
-      #
-      # @param smoothing_param [Float] The smoothing parameter.
-      def initialize(smoothing_param: 1.0)
-        check_params_numeric(smoothing_param: smoothing_param)
-        check_params_positive(smoothing_param: smoothing_param)
-        @params = {}
-        @params[:smoothing_param] = smoothing_param
-      end
-
-      # Fit the model with given training data.
-      #
-      # @param x [Numo::DFloat] (shape: [n_samples, n_features]) The training data to be used for fitting the model.
-      # @param y [Numo::Int32] (shape: [n_samples]) The categorical variables (e.g. labels)
-      #   to be used for fitting the model.
-      # @return [ComplementNB] The learned classifier itself.
-      def fit(x, y)
-        x = check_convert_sample_array(x)
-        y = check_convert_label_array(y)
-        check_sample_label_size(x, y)
-        n_samples, = x.shape
-        @classes = Numo::Int32[*y.to_a.uniq.sort]
-        @class_priors = Numo::DFloat[*@classes.to_a.map { |l| y.eq(l).count.fdiv(n_samples) }]
-        @class_log_probs = Numo::NMath.log(1 / (1 - @class_priors))
-        compl_features = Numo::DFloat[*@classes.to_a.map { |l| x[y.ne(l).where, true].sum(0) }]
-        compl_features += @params[:smoothing_param]
-        n_classes = @classes.size
-        @feature_probs = compl_features / compl_features.sum(1).reshape(n_classes, 1)
-        @weights = Numo::NMath.log(@feature_probs)
-        self
-      end
-
-      # Calculate confidence scores for samples.
-      #
-      # @param x [Numo::DFloat] (shape: [n_samples, n_features]) The samples to compute the scores.
-      # @return [Numo::DFloat] (shape: [n_samples, n_classes]) Confidence scores per sample for each class.
-      def decision_function(x)
-        x = check_convert_sample_array(x)
-        @class_log_probs - x.dot(@weights.transpose)
-      end
-    end
-  end
-end

data/lib/rumale/nearest_neighbors/k_neighbors_classifier.rb

@@ -1,133 +0,0 @@
-# frozen_string_literal: true
-
-require 'rumale/base/base_estimator'
-require 'rumale/base/classifier'
-
-module Rumale
-  # This module consists of the classes that implement estimators based on nearest neighbors rule.
-  module NearestNeighbors
-    # KNeighborsClassifier is a class that implements the classifier with the k-nearest neighbors rule.
-    # The current implementation uses the Euclidean distance for finding the neighbors.
-    #
-    # @example
-    #   estimator =
-    #     Rumale::NearestNeighbors::KNeighborsClassifier.new(n_neighbors: 5)
-    #   estimator.fit(training_samples, traininig_labels)
-    #   results = estimator.predict(testing_samples)
-    #
-    class KNeighborsClassifier
-      include Base::BaseEstimator
-      include Base::Classifier
-
-      # Return the prototypes for the nearest neighbor classifier.
-      # If the metric is 'precomputed', that returns nil.
-      # If the algorithm is 'vptree', that returns Rumale::NearestNeighbors::VPTree.
-      # @return [Numo::DFloat] (shape: [n_training_samples, n_features])
-      attr_reader :prototypes
-
-      # Return the labels of the prototypes
-      # @return [Numo::Int32] (size: n_training_samples)
-      attr_reader :labels
-
-      # Return the class labels.
-      # @return [Numo::Int32] (size: n_classes)
-      attr_reader :classes
-
-      # Create a new classifier with the nearest neighbor rule.
-      #
-      # @param n_neighbors [Integer] The number of neighbors.
-      # @param algorithm [String] The algorithm is used for finding the nearest neighbors.
-      #   If algorithm is 'brute', brute-force search will be used.
-      #   If algorithm is 'vptree', vantage point tree will be used.
-      #   This parameter is ignored when metric parameter is 'precomputed'.
-      # @param metric [String] The metric to calculate the distances.
-      #   If metric is 'euclidean', Euclidean distance is calculated for distance between points.
-      #   If metric is 'precomputed', the fit and predict methods expect to be given a distance matrix.
-      def initialize(n_neighbors: 5, algorithm: 'brute', metric: 'euclidean')
-        check_params_numeric(n_neighbors: n_neighbors)
-        check_params_positive(n_neighbors: n_neighbors)
-        check_params_string(algorith: algorithm, metric: metric)
-        @params = {}
-        @params[:n_neighbors] = n_neighbors
-        @params[:algorithm] = algorithm == 'vptree' ? 'vptree' : 'brute'
-        @params[:metric] = metric == 'precomputed' ? 'precomputed' : 'euclidean'
-        @prototypes = nil
-        @labels = nil
-        @classes = nil
-      end
-
-      # Fit the model with given training data.
-      #
-      # @param x [Numo::DFloat] (shape: [n_training_samples, n_features]) The training data to be used for fitting the model.
-      #   If the metric is 'precomputed', x must be a square distance matrix (shape: [n_training_samples, n_training_samples]).
-      # @param y [Numo::Int32] (shape: [n_training_samples]) The labels to be used for fitting the model.
-      # @return [KNeighborsClassifier] The learned classifier itself.
-      def fit(x, y)
-        x = check_convert_sample_array(x)
-        y = check_convert_label_array(y)
-        check_sample_label_size(x, y)
-        raise ArgumentError, 'Expect the input distance matrix to be square.' if @params[:metric] == 'precomputed' && x.shape[0] != x.shape[1]
-
-        @prototypes = if @params[:metric] == 'euclidean'
-                        if @params[:algorithm] == 'vptree'
-                          VPTree.new(x)
-                        else
-                          x.dup
-                        end
-                      end
-        @labels = Numo::Int32.asarray(y.to_a)
-        @classes = Numo::Int32.asarray(y.to_a.uniq.sort)
-        self
-      end
-
-      # Calculate confidence scores for samples.
-      #
-      # @param x [Numo::DFloat] (shape: [n_testing_samples, n_features]) The samples to compute the scores.
-      #   If the metric is 'precomputed', x must be a square distance matrix (shape: [n_testing_samples, n_training_samples]).
-      # @return [Numo::DFloat] (shape: [n_testing_samples, n_classes]) Confidence scores per sample for each class.
-      def decision_function(x)
-        x = check_convert_sample_array(x)
-        if @params[:metric] == 'precomputed' && x.shape[1] != @labels.size
-          raise ArgumentError, 'Expect the size input matrix to be n_testing_samples-by-n_training_samples.'
-        end
-
-        n_prototypes = @labels.size
-        n_neighbors = [@params[:n_neighbors], n_prototypes].min
-        n_samples = x.shape[0]
-        n_classes = @classes.size
-        scores = Numo::DFloat.zeros(n_samples, n_classes)
-
-        if @params[:metric] == 'euclidean' && @params[:algorithm] == 'vptree'
-          neighbor_ids, = @prototypes.query(x, n_neighbors)
-          n_samples.times do |m|
-            neighbor_ids[m, true].each { |n| scores[m, @classes.to_a.index(@labels[n])] += 1.0 }
-          end
-        else
-          distance_matrix = @params[:metric] == 'precomputed' ? x : PairwiseMetric.euclidean_distance(x, @prototypes)
-          n_samples.times do |m|
-            neighbor_ids = distance_matrix[m, true].to_a.each_with_index.sort.map(&:last)[0...n_neighbors]
-            neighbor_ids.each { |n| scores[m, @classes.to_a.index(@labels[n])] += 1.0 }
-          end
-        end
-
-        scores
-      end
-
-      # Predict class labels for samples.
-      #
-      # @param x [Numo::DFloat] (shape: [n_testing_samples, n_features]) The samples to predict the labels.
-      #   If the metric is 'precomputed', x must be a square distance matrix (shape: [n_testing_samples, n_training_samples]).
-      # @return [Numo::Int32] (shape: [n_testing_samples]) Predicted class label per sample.
-      def predict(x)
-        x = check_convert_sample_array(x)
-        if @params[:metric] == 'precomputed' && x.shape[1] != @labels.size
-          raise ArgumentError, 'Expect the size input matrix to be n_samples-by-n_training_samples.'
-        end
-
-        decision_values = decision_function(x)
-        n_samples = x.shape[0]
-        Numo::Int32.asarray(Array.new(n_samples) { |n| @classes[decision_values[n, true].max_index] })
-      end
-    end
-  end
-end

data/lib/rumale/nearest_neighbors/k_neighbors_regressor.rb

@@ -1,108 +0,0 @@
-# frozen_string_literal: true
-
-require 'rumale/base/base_estimator'
-require 'rumale/base/regressor'
-
-module Rumale
-  module NearestNeighbors
-    # KNeighborsRegressor is a class that implements the regressor with the k-nearest neighbors rule.
-    # The current implementation uses the Euclidean distance for finding the neighbors.
-    #
-    # @example
-    #   estimator =
-    #     Rumale::NearestNeighbors::KNeighborsRegressor.new(n_neighbors: 5)
-    #   estimator.fit(training_samples, traininig_target_values)
-    #   results = estimator.predict(testing_samples)
-    #
-    class KNeighborsRegressor
-      include Base::BaseEstimator
-      include Base::Regressor
-
-      # Return the prototypes for the nearest neighbor regressor.
-      # If the metric is 'precomputed', that returns nil.
-      # If the algorithm is 'vptree', that returns Rumale::NearestNeighbors::VPTree.
-      # @return [Numo::DFloat] (shape: [n_training_samples, n_features])
-      attr_reader :prototypes
-
-      # Return the values of the prototypes
-      # @return [Numo::DFloat] (shape: [n_training_samples, n_outputs])
-      attr_reader :values
-
-      # Create a new regressor with the nearest neighbor rule.
-      #
-      # @param n_neighbors [Integer] The number of neighbors.
-      # @param algorithm [String] The algorithm is used for finding the nearest neighbors.
-      #   If algorithm is 'brute', brute-force search will be used.
-      #   If algorithm is 'vptree', vantage point tree will be used.
-      #   This parameter is ignored when metric parameter is 'precomputed'.
-      # @param metric [String] The metric to calculate the distances.
-      #   If metric is 'euclidean', Euclidean distance is calculated for distance between points.
-      #   If metric is 'precomputed', the fit and predict methods expect to be given a distance matrix.
-      def initialize(n_neighbors: 5, algorithm: 'brute', metric: 'euclidean')
-        check_params_numeric(n_neighbors: n_neighbors)
-        check_params_positive(n_neighbors: n_neighbors)
-        check_params_string(algorith: algorithm, metric: metric)
-        @params = {}
-        @params[:n_neighbors] = n_neighbors
-        @params[:algorithm] = algorithm == 'vptree' ? 'vptree' : 'brute'
-        @params[:metric] = metric == 'precomputed' ? 'precomputed' : 'euclidean'
-        @prototypes = nil
-        @values = nil
-      end
-
-      # Fit the model with given training data.
-      #
-      # @param x [Numo::DFloat] (shape: [n_training_samples, n_features]) The training data to be used for fitting the model.
-      #   If the metric is 'precomputed', x must be a square distance matrix (shape: [n_training_samples, n_training_samples]).
-      # @param y [Numo::DFloat] (shape: [n_training_samples, n_outputs]) The target values to be used for fitting the model.
-      # @return [KNeighborsRegressor] The learned regressor itself.
-      def fit(x, y)
-        x = check_convert_sample_array(x)
-        y = check_convert_tvalue_array(y)
-        check_sample_tvalue_size(x, y)
-        raise ArgumentError, 'Expect the input distance matrix to be square.' if @params[:metric] == 'precomputed' && x.shape[0] != x.shape[1]
-
-        @prototypes = if @params[:metric] == 'euclidean'
-                        if @params[:algorithm] == 'vptree'
-                          VPTree.new(x)
-                        else
-                          x.dup
-                        end
-                      end
-        @values = y.dup
-        self
-      end
-
-      # Predict values for samples.
-      #
-      # @param x [Numo::DFloat] (shape: [n_testing_samples, n_features]) The samples to predict the values.
-      #   If the metric is 'precomputed', x must be a square distance matrix (shape: [n_testing_samples, n_training_samples]).
-      # @return [Numo::DFloat] (shape: [n_testing_samples, n_outputs]) Predicted values per sample.
-      def predict(x)
-        x = check_convert_sample_array(x)
-        if @params[:metric] == 'precomputed' && x.shape[1] != @values.shape[0]
-          raise ArgumentError, 'Expect the size input matrix to be n_testing_samples-by-n_training_samples.'
-        end
-
-        # Initialize some variables.
-        n_samples = x.shape[0]
-        n_prototypes, n_outputs = @values.shape
-        n_neighbors = [@params[:n_neighbors], n_prototypes].min
-        # Predict values for the given samples.
-        if @params[:metric] == 'euclidean' && @params[:algorithm] == 'vptree'
-          neighbor_ids, = @prototypes.query(x, n_neighbors)
-          predicted_values = Array.new(n_samples) do |n|
-            n_outputs.nil? ? @values[neighbor_ids[n, true]].mean : @values[neighbor_ids[n, true], true].mean(0).to_a
-          end
-        else
-          distance_matrix = @params[:metric] == 'precomputed' ? x : PairwiseMetric.euclidean_distance(x, @prototypes)
-          predicted_values = Array.new(n_samples) do |n|
-            neighbor_ids = distance_matrix[n, true].to_a.each_with_index.sort.map(&:last)[0...n_neighbors]
-            n_outputs.nil? ? @values[neighbor_ids].mean : @values[neighbor_ids, true].mean(0).to_a
-          end
-        end
-        Numo::DFloat[*predicted_values]
-      end
-    end
-  end
-end