rumale 0.23.3 → 0.24.0

data/lib/rumale/base/base_estimator.rb

@@ -1,49 +0,0 @@
-# frozen_string_literal: true
-
-module Rumale
-  # This module consists of basic mix-in classes.
-  module Base
-    # Base module for all estimators in Rumale.
-    module BaseEstimator
-      # Return parameters about an estimator.
-      # @return [Hash]
-      attr_reader :params
-
-      private
-
-      def enable_linalg?(warning: true)
-        if defined?(Numo::Linalg).nil?
-          warn('If you want to use features that depend on Numo::Linalg, you should install and load Numo::Linalg in advance.') if warning
-          return false
-        end
-        if Numo::Linalg::VERSION < '0.1.4'
-          if warning
-            warn('The loaded Numo::Linalg does not implement the methods required by Rumale. Please load Numo::Linalg version 0.1.4 or later.')
-          end
-          return false
-        end
-        true
-      end
-
-      def enable_parallel?
-        return false if @params[:n_jobs].nil?
-
-        if defined?(Parallel).nil?
-          warn('If you want to use parallel option, you should install and load Parallel in advance.')
-          return false
-        end
-        true
-      end
-
-      def n_processes
-        return 1 unless enable_parallel?
-
-        @params[:n_jobs] <= 0 ? Parallel.processor_count : @params[:n_jobs]
-      end
-
-      def parallel_map(n_outputs, &block)
-        Parallel.map(Array.new(n_outputs) { |v| v }, in_processes: n_processes, &block)
-      end
-    end
-  end
-end

data/lib/rumale/base/classifier.rb

@@ -1,36 +0,0 @@
-# frozen_string_literal: true
-
-require 'rumale/validation'
-require 'rumale/evaluation_measure/accuracy'
-
-module Rumale
-  module Base
-    # Module for all classifiers in Rumale.
-    module Classifier
-      include Validation
-
-      # An abstract method for fitting a model.
-      def fit
-        raise NotImplementedError, "#{__method__} has to be implemented in #{self.class}."
-      end
-
-      # An abstract method for predicting labels.
-      def predict
-        raise NotImplementedError, "#{__method__} has to be implemented in #{self.class}."
-      end
-
-      # Calculate the mean accuracy of the given testing data.
-      #
-      # @param x [Numo::DFloat] (shape: [n_samples, n_features]) Testing data.
-      # @param y [Numo::Int32] (shape: [n_samples]) True labels for testing data.
-      # @return [Float] Mean accuracy
-      def score(x, y)
-        x = check_convert_sample_array(x)
-        y = check_convert_label_array(y)
-        check_sample_label_size(x, y)
-        evaluator = Rumale::EvaluationMeasure::Accuracy.new
-        evaluator.score(y, predict(x))
-      end
-    end
-  end
-end

data/lib/rumale/base/cluster_analyzer.rb

@@ -1,31 +0,0 @@
-# frozen_string_literal: true
-
-require 'rumale/validation'
-require 'rumale/evaluation_measure/purity'
-
-module Rumale
-  module Base
-    # Module for all clustering algorithms in Rumale.
-    module ClusterAnalyzer
-      include Validation
-
-      # An abstract method for analyzing clusters and predicting cluster indices.
-      def fit_predict
-        raise NotImplementedError, "#{__method__} has to be implemented in #{self.class}."
-      end
-
-      # Calculate purity of clustering result.
-      #
-      # @param x [Numo::DFloat] (shape: [n_samples, n_features]) Testing data.
-      # @param y [Numo::Int32] (shape: [n_samples]) True labels for testing data.
-      # @return [Float] Purity
-      def score(x, y)
-        x = check_convert_sample_array(x)
-        y = check_convert_label_array(y)
-        check_sample_label_size(x, y)
-        evaluator = Rumale::EvaluationMeasure::Purity.new
-        evaluator.score(y, fit_predict(x))
-      end
-    end
-  end
-end

data/lib/rumale/base/evaluator.rb

@@ -1,17 +0,0 @@
-# frozen_string_literal: true
-
-require 'rumale/validation'
-
-module Rumale
-  module Base
-    # Module for all evaluation measures in Rumale.
-    module Evaluator
-      include Validation
-
-      # An abstract method for evaluation of model.
-      def score
-        raise NotImplementedError, "#{__method__} has to be implemented in #{self.class}."
-      end
-    end
-  end
-end

data/lib/rumale/base/regressor.rb

@@ -1,36 +0,0 @@
-# frozen_string_literal: true
-
-require 'rumale/validation'
-require 'rumale/evaluation_measure/r2_score'
-
-module Rumale
-  module Base
-    # Module for all regressors in Rumale.
-    module Regressor
-      include Validation
-
-      # An abstract method for fitting a model.
-      def fit
-        raise NotImplementedError, "#{__method__} has to be implemented in #{self.class}."
-      end
-
-      # An abstract method for predicting labels.
-      def predict
-        raise NotImplementedError, "#{__method__} has to be implemented in #{self.class}."
-      end
-
-      # Calculate the coefficient of determination for the given testing data.
-      #
-      # @param x [Numo::DFloat] (shape: [n_samples, n_features]) Testing data.
-      # @param y [Numo::DFloat] (shape: [n_samples, n_outputs]) Target values for testing data.
-      # @return [Float] Coefficient of determination
-      def score(x, y)
-        x = check_convert_sample_array(x)
-        y = check_convert_tvalue_array(y)
-        check_sample_tvalue_size(x, y)
-        evaluator = Rumale::EvaluationMeasure::R2Score.new
-        evaluator.score(y, predict(x))
-      end
-    end
-  end
-end

data/lib/rumale/base/splitter.rb

@@ -1,21 +0,0 @@
-# frozen_string_literal: true
-
-require 'rumale/validation'
-
-module Rumale
-  module Base
-    # Module for all validation methods in Rumale.
-    module Splitter
-      include Validation
-
-      # Return the number of splits.
-      # @return [Integer]
-      attr_reader :n_splits
-
-      # An abstract method for splitting dataset.
-      def split
-        raise NotImplementedError, "#{__method__} has to be implemented in #{self.class}."
-      end
-    end
-  end
-end

data/lib/rumale/base/transformer.rb

@@ -1,22 +0,0 @@
-# frozen_string_literal: true
-
-require 'rumale/validation'
-
-module Rumale
-  module Base
-    # Module for all transfomers in Rumale.
-    module Transformer
-      include Validation
-
-      # An abstract method for fitting a model.
-      def fit
-        raise NotImplementedError, "#{__method__} has to be implemented in #{self.class}."
-      end
-
-      # An abstract method for fitting a model and transforming given data.
-      def fit_transform
-        raise NotImplementedError, "#{__method__} has to be implemented in #{self.class}."
-      end
-    end
-  end
-end

data/lib/rumale/clustering/dbscan.rb

@@ -1,123 +0,0 @@
-# frozen_string_literal: true
-
-require 'rumale/base/base_estimator'
-require 'rumale/base/cluster_analyzer'
-require 'rumale/pairwise_metric'
-
-module Rumale
-  module Clustering
-    # DBSCAN is a class that implements DBSCAN cluster analysis.
-    #
-    # @example
-    #   analyzer = Rumale::Clustering::DBSCAN.new(eps: 0.5, min_samples: 5)
-    #   cluster_labels = analyzer.fit_predict(samples)
-    #
-    # *Reference*
-    # - Ester, M., Kriegel, H-P., Sander, J., and Xu, X., "A density-based algorithm for discovering clusters in large spatial databases with noise," Proc. KDD' 96, pp. 266--231, 1996.
-    class DBSCAN
-      include Base::BaseEstimator
-      include Base::ClusterAnalyzer
-
-      # Return the core sample indices.
-      # @return [Numo::Int32] (shape: [n_core_samples])
-      attr_reader :core_sample_ids
-
-      # Return the cluster labels. The negative cluster label indicates that the point is noise.
-      # @return [Numo::Int32] (shape: [n_samples])
-      attr_reader :labels
-
-      # Create a new cluster analyzer with DBSCAN method.
-      #
-      # @param eps [Float] The radius of neighborhood.
-      # @param min_samples [Integer] The number of neighbor samples to be used for the criterion whether a point is a core point.
-      # @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 fit_transform methods expect to be given a distance matrix.
-      def initialize(eps: 0.5, min_samples: 5, metric: 'euclidean')
-        check_params_numeric(eps: eps, min_samples: min_samples)
-        check_params_string(metric: metric)
-        @params = {}
-        @params[:eps] = eps
-        @params[:min_samples] = min_samples
-        @params[:metric] = metric == 'precomputed' ? 'precomputed' : 'euclidean'
-        @core_sample_ids = nil
-        @labels = nil
-      end
-
-      # Analysis clusters with given training data.
-      #
-      # @overload fit(x) -> DBSCAN
-      #
-      # @param x [Numo::DFloat] (shape: [n_samples, n_features]) The training data to be used for cluster analysis.
-      #   If the metric is 'precomputed', x must be a square distance matrix (shape: [n_samples, n_samples]).
-      # @return [DBSCAN] The learned cluster analyzer itself.
-      def fit(x, _y = nil)
-        x = check_convert_sample_array(x)
-        raise ArgumentError, 'Expect the input distance matrix to be square.' if @params[:metric] == 'precomputed' && x.shape[0] != x.shape[1]
-
-        partial_fit(x)
-        self
-      end
-
-      # Analysis clusters and assign samples to clusters.
-      #
-      # @param x [Numo::DFloat] (shape: [n_samples, n_features]) The samples to be used for cluster analysis.
-      #   If the metric is 'precomputed', x must be a square distance matrix (shape: [n_samples, n_samples]).
-      # @return [Numo::Int32] (shape: [n_samples]) Predicted cluster label per sample.
-      def fit_predict(x)
-        x = check_convert_sample_array(x)
-        raise ArgumentError, 'Expect the input distance matrix to be square.' if @params[:metric] == 'precomputed' && x.shape[0] != x.shape[1]
-
-        partial_fit(x)
-        labels
-      end
-
-      private
-
-      def partial_fit(x)
-        cluster_id = 0
-        metric_mat = calc_pairwise_metrics(x)
-        n_samples = metric_mat.shape[0]
-        @core_sample_ids = []
-        @labels = Numo::Int32.zeros(n_samples) - 2
-        n_samples.times do |query_id|
-          next if @labels[query_id] >= -1
-
-          cluster_id += 1 if expand_cluster(metric_mat, query_id, cluster_id)
-        end
-        @core_sample_ids = Numo::Int32[*@core_sample_ids.flatten]
-        nil
-      end
-
-      def calc_pairwise_metrics(x)
-        @params[:metric] == 'precomputed' ? x : Rumale::PairwiseMetric.euclidean_distance(x)
-      end
-
-      def expand_cluster(metric_mat, query_id, cluster_id)
-        target_ids = region_query(metric_mat[query_id, true])
-        if target_ids.size < @params[:min_samples]
-          @labels[query_id] = -1
-          false
-        else
-          @labels[target_ids] = cluster_id
-          @core_sample_ids.push(target_ids.dup)
-          target_ids.delete(query_id)
-          while (m = target_ids.shift)
-            neighbor_ids = region_query(metric_mat[m, true])
-            next if neighbor_ids.size < @params[:min_samples]
-
-            neighbor_ids.each do |n|
-              target_ids.push(n) if @labels[n] < -1
-              @labels[n] = cluster_id if @labels[n] <= -1
-            end
-          end
-          true
-        end
-      end
-
-      def region_query(metric_arr)
-        metric_arr.lt(@params[:eps]).where.to_a
-      end
-    end
-  end
-end

data/lib/rumale/clustering/gaussian_mixture.rb

@@ -1,218 +0,0 @@
-# frozen_string_literal: true
-
-require 'rumale/base/base_estimator'
-require 'rumale/base/cluster_analyzer'
-require 'rumale/preprocessing/label_binarizer'
-
-module Rumale
-  module Clustering
-    # GaussianMixture is a class that implements cluster analysis with gaussian mixture model.
-    #
-    # @example
-    #   analyzer = Rumale::Clustering::GaussianMixture.new(n_clusters: 10, max_iter: 50)
-    #   cluster_labels = analyzer.fit_predict(samples)
-    #
-    #   # If Numo::Linalg is installed, you can specify 'full' for the tyep of covariance option.
-    #   require 'numo/linalg/autoloader'
-    #   analyzer = Rumale::Clustering::GaussianMixture.new(n_clusters: 10, max_iter: 50, covariance_type: 'full')
-    #   cluster_labels = analyzer.fit_predict(samples)
-    #
-    class GaussianMixture
-      include Base::BaseEstimator
-      include Base::ClusterAnalyzer
-
-      # Return the number of iterations to covergence.
-      # @return [Integer]
-      attr_reader :n_iter
-
-      # Return the weight of each cluster.
-      # @return [Numo::DFloat] (shape: [n_clusters])
-      attr_reader :weights
-
-      # Return the mean of each cluster.
-      # @return [Numo::DFloat] (shape: [n_clusters, n_features])
-      attr_reader :means
-
-      # Return the diagonal elements of covariance matrix of each cluster.
-      # @return [Numo::DFloat] (shape: [n_clusters, n_features] if 'diag', [n_clusters, n_features, n_features] if 'full')
-      attr_reader :covariances
-
-      # Create a new cluster analyzer with gaussian mixture model.
-      #
-      # @param n_clusters [Integer] The number of clusters.
-      # @param init [String] The initialization method for centroids ('random' or 'k-means++').
-      # @param covariance_type [String] The type of covariance parameter to be used ('diag' or 'full').
-      # @param max_iter [Integer] The maximum number of iterations.
-      # @param tol [Float] The tolerance of termination criterion.
-      # @param reg_covar [Float] The non-negative regularization to the diagonal of covariance.
-      # @param random_seed [Integer] The seed value using to initialize the random generator.
-      def initialize(n_clusters: 8, init: 'k-means++', covariance_type: 'diag', max_iter: 50, tol: 1.0e-4, reg_covar: 1.0e-6, random_seed: nil)
-        check_params_numeric(n_clusters: n_clusters, max_iter: max_iter, tol: tol)
-        check_params_string(init: init)
-        check_params_numeric_or_nil(random_seed: random_seed)
-        check_params_positive(n_clusters: n_clusters, max_iter: max_iter)
-        @params = {}
-        @params[:n_clusters] = n_clusters
-        @params[:init] = init == 'random' ? 'random' : 'k-means++'
-        @params[:covariance_type] = covariance_type == 'full' ? 'full' : 'diag'
-        @params[:max_iter] = max_iter
-        @params[:tol] = tol
-        @params[:reg_covar] = reg_covar
-        @params[:random_seed] = random_seed
-        @params[:random_seed] ||= srand
-        @n_iter = nil
-        @weights = nil
-        @means = nil
-        @covariances = nil
-      end
-
-      # Analysis clusters with given training data.
-      #
-      # @overload fit(x) -> GaussianMixture
-      #
-      # @param x [Numo::DFloat] (shape: [n_samples, n_features]) The training data to be used for cluster analysis.
-      # @return [GaussianMixture] The learned cluster analyzer itself.
-      def fit(x, _y = nil)
-        x = check_convert_sample_array(x)
-        check_enable_linalg('fit')
-
-        n_samples = x.shape[0]
-        memberships = init_memberships(x)
-        @params[:max_iter].times do |t|
-          @n_iter = t
-          @weights = calc_weights(n_samples, memberships)
-          @means = calc_means(x, memberships)
-          @covariances = calc_covariances(x, @means, memberships, @params[:reg_covar], @params[:covariance_type])
-          new_memberships = calc_memberships(x, @weights, @means, @covariances, @params[:covariance_type])
-          error = (memberships - new_memberships).abs.max
-          break if error <= @params[:tol]
-
-          memberships = new_memberships.dup
-        end
-        self
-      end
-
-      # Predict cluster labels for samples.
-      #
-      # @param x [Numo::DFloat] (shape: [n_samples, n_features]) The samples to predict the cluster label.
-      # @return [Numo::Int32] (shape: [n_samples]) Predicted cluster label per sample.
-      def predict(x)
-        x = check_convert_sample_array(x)
-        check_enable_linalg('predict')
-
-        memberships = calc_memberships(x, @weights, @means, @covariances, @params[:covariance_type])
-        assign_cluster(memberships)
-      end
-
-      # Analysis clusters and assign samples to clusters.
-      #
-      # @param x [Numo::DFloat] (shape: [n_samples, n_features]) The training data to be used for cluster analysis.
-      # @return [Numo::Int32] (shape: [n_samples]) Predicted cluster label per sample.
-      def fit_predict(x)
-        x = check_convert_sample_array(x)
-        check_enable_linalg('fit_predict')
-
-        fit(x).predict(x)
-      end
-
-      private
-
-      def assign_cluster(memberships)
-        n_clusters = memberships.shape[1]
-        memberships.max_index(axis: 1) - Numo::Int32[*0.step(memberships.size - 1, n_clusters)]
-      end
-
-      def init_memberships(x)
-        kmeans = Rumale::Clustering::KMeans.new(
-          n_clusters: @params[:n_clusters], init: @params[:init], max_iter: 0, random_seed: @params[:random_seed]
-        )
-        cluster_ids = kmeans.fit_predict(x)
-        encoder = Rumale::Preprocessing::LabelBinarizer.new
-        Numo::DFloat.cast(encoder.fit_transform(cluster_ids))
-      end
-
-      def calc_memberships(x, weights, means, covars, covar_type)
-        n_samples = x.shape[0]
-        n_clusters = means.shape[0]
-        memberships = Numo::DFloat.zeros(n_samples, n_clusters)
-        n_clusters.times do |n|
-          centered = x - means[n, true]
-          covar = covar_type == 'full' ? covars[n, true, true] : covars[n, true]
-          memberships[true, n] = calc_unnormalized_membership(centered, weights[n], covar, covar_type)
-        end
-        memberships / memberships.sum(1).expand_dims(1)
-      end
-
-      def calc_weights(n_samples, memberships)
-        memberships.sum(0) / n_samples
-      end
-
-      def calc_means(x, memberships)
-        memberships.transpose.dot(x) / memberships.sum(0).expand_dims(1)
-      end
-
-      def calc_covariances(x, means, memberships, reg_cover, covar_type)
-        if covar_type == 'full'
-          calc_full_covariances(x, means, reg_cover, memberships)
-        else
-          calc_diag_covariances(x, means, reg_cover, memberships)
-        end
-      end
-
-      def calc_diag_covariances(x, means, reg_cover, memberships)
-        n_clusters = means.shape[0]
-        diag_cov = Array.new(n_clusters) do |n|
-          centered = x - means[n, true]
-          memberships[true, n].dot(centered**2) / memberships[true, n].sum
-        end
-        Numo::DFloat.asarray(diag_cov) + reg_cover
-      end
-
-      def calc_full_covariances(x, means, reg_cover, memberships)
-        n_features = x.shape[1]
-        n_clusters = means.shape[0]
-        cov_mats = Numo::DFloat.zeros(n_clusters, n_features, n_features)
-        reg_mat = Numo::DFloat.eye(n_features) * reg_cover
-        n_clusters.times do |n|
-          centered = x - means[n, true]
-          members = memberships[true, n]
-          cov_mats[n, true, true] = reg_mat + (centered.transpose * members).dot(centered) / members.sum
-        end
-        cov_mats
-      end
-
-      def calc_unnormalized_membership(centered, weight, covar, covar_type)
-        inv_covar = calc_inv_covariance(covar, covar_type)
-        inv_sqrt_det_covar = calc_inv_sqrt_det_covariance(covar, covar_type)
-        distances = if covar_type == 'full'
-                      (centered.dot(inv_covar) * centered).sum(1)
-                    else
-                      (centered * inv_covar * centered).sum(1)
-                    end
-        weight * inv_sqrt_det_covar * Numo::NMath.exp(-0.5 * distances)
-      end
-
-      def calc_inv_covariance(covar, covar_type)
-        if covar_type == 'full'
-          Numo::Linalg.inv(covar)
-        else
-          1.0 / covar
-        end
-      end
-
-      def calc_inv_sqrt_det_covariance(covar, covar_type)
-        if covar_type == 'full'
-          1.0 / Math.sqrt(Numo::Linalg.det(covar))
-        else
-          1.0 / Math.sqrt(covar.prod)
-        end
-      end
-
-      def check_enable_linalg(method_name)
-        return unless @params[:covariance_type] == 'full' && !enable_linalg?
-
-        raise "GaussianMixture##{method_name} requires Numo::Linalg when covariance_type is 'full' but that is not loaded."
-      end
-    end
-  end
-end