rumale 0.8.0

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require 'bundler/setup'
+require 'rumale'
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require 'pry'
+# Pry.start
+
+require 'irb'
+IRB.start(__FILE__)

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/lib/rumale.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+require 'numo/narray'
+
+require 'rumale/version'
+require 'rumale/validation'
+require 'rumale/values'
+require 'rumale/utils'
+require 'rumale/pairwise_metric'
+require 'rumale/dataset'
+require 'rumale/probabilistic_output'
+require 'rumale/base/base_estimator'
+require 'rumale/base/classifier'
+require 'rumale/base/regressor'
+require 'rumale/base/cluster_analyzer'
+require 'rumale/base/transformer'
+require 'rumale/base/splitter'
+require 'rumale/base/evaluator'
+require 'rumale/optimizer/sgd'
+require 'rumale/optimizer/rmsprop'
+require 'rumale/optimizer/nadam'
+require 'rumale/optimizer/yellow_fin'
+require 'rumale/pipeline/pipeline'
+require 'rumale/kernel_approximation/rbf'
+require 'rumale/linear_model/base_linear_model'
+require 'rumale/linear_model/svc'
+require 'rumale/linear_model/svr'
+require 'rumale/linear_model/logistic_regression'
+require 'rumale/linear_model/linear_regression'
+require 'rumale/linear_model/ridge'
+require 'rumale/linear_model/lasso'
+require 'rumale/kernel_machine/kernel_svc'
+require 'rumale/polynomial_model/base_factorization_machine'
+require 'rumale/polynomial_model/factorization_machine_classifier'
+require 'rumale/polynomial_model/factorization_machine_regressor'
+require 'rumale/multiclass/one_vs_rest_classifier'
+require 'rumale/nearest_neighbors/k_neighbors_classifier'
+require 'rumale/nearest_neighbors/k_neighbors_regressor'
+require 'rumale/naive_bayes/naive_bayes'
+require 'rumale/tree/node'
+require 'rumale/tree/base_decision_tree'
+require 'rumale/tree/decision_tree_classifier'
+require 'rumale/tree/decision_tree_regressor'
+require 'rumale/ensemble/ada_boost_classifier'
+require 'rumale/ensemble/ada_boost_regressor'
+require 'rumale/ensemble/random_forest_classifier'
+require 'rumale/ensemble/random_forest_regressor'
+require 'rumale/clustering/k_means'
+require 'rumale/clustering/dbscan'
+require 'rumale/decomposition/pca'
+require 'rumale/decomposition/nmf'
+require 'rumale/preprocessing/l2_normalizer'
+require 'rumale/preprocessing/min_max_scaler'
+require 'rumale/preprocessing/standard_scaler'
+require 'rumale/preprocessing/label_encoder'
+require 'rumale/preprocessing/one_hot_encoder'
+require 'rumale/model_selection/k_fold'
+require 'rumale/model_selection/stratified_k_fold'
+require 'rumale/model_selection/cross_validation'
+require 'rumale/model_selection/grid_search_cv'
+require 'rumale/evaluation_measure/accuracy'
+require 'rumale/evaluation_measure/precision'
+require 'rumale/evaluation_measure/recall'
+require 'rumale/evaluation_measure/f_score'
+require 'rumale/evaluation_measure/log_loss'
+require 'rumale/evaluation_measure/r2_score'
+require 'rumale/evaluation_measure/mean_squared_error'
+require 'rumale/evaluation_measure/mean_absolute_error'
+require 'rumale/evaluation_measure/purity'
+require 'rumale/evaluation_measure/normalized_mutual_information'

data/lib/rumale/base/base_estimator.rb

@@ -0,0 +1,13 @@
+# 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
+    end
+  end
+end

data/lib/rumale/base/classifier.rb

@@ -0,0 +1,36 @@
+# 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)
+        check_sample_array(x)
+        check_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

@@ -0,0 +1,31 @@
+# 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)
+        check_sample_array(x)
+        check_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

@@ -0,0 +1,17 @@
+# 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

@@ -0,0 +1,36 @@
+# 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)
+        check_sample_array(x)
+        check_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

@@ -0,0 +1,21 @@
+# 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

@@ -0,0 +1,22 @@
+# 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

@@ -0,0 +1,125 @@
+# 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.
+    # The current implementation uses the Euclidean distance for analyzing the clusters.
+    #
+    # @example
+    #   analyzer = Rumale::Clustering::DBSCAN.new(eps: 0.5, min_samples: 5)
+    #   cluster_labels = analyzer.fit_predict(samples)
+    #
+    # *Reference*
+    # - M. Ester, H-P. Kriegel, J. Sander, and X. Xu, "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.
+      def initialize(eps: 0.5, min_samples: 5)
+        check_params_float(eps: eps)
+        check_params_integer(min_samples: min_samples)
+        @params = {}
+        @params[:eps] = eps
+        @params[:min_samples] = min_samples
+        @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.
+      # @return [DBSCAN] The learned cluster analyzer itself.
+      def fit(x, _y = nil)
+        check_sample_array(x)
+        partial_fit(x)
+        self
+      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)
+        check_sample_array(x)
+        partial_fit(x)
+        labels
+      end
+
+      # Dump marshal data.
+      # @return [Hash] The marshal data.
+      def marshal_dump
+        { params: @params,
+          core_sample_ids: @core_sample_ids,
+          labels: @labels }
+      end
+
+      # Load marshal data.
+      # @return [nil]
+      def marshal_load(obj)
+        @params = obj[:params]
+        @core_sample_ids = obj[:core_sample_ids]
+        @labels = obj[:labels]
+        nil
+      end
+
+      private
+
+      def partial_fit(x)
+        cluster_id = 0
+        n_samples  = x.shape[0]
+        @core_sample_ids = []
+        @labels = Numo::Int32.zeros(n_samples) - 2
+        n_samples.times do |q|
+          next if @labels[q] >= -1
+          cluster_id += 1 if expand_cluster(x, q, cluster_id)
+        end
+        @core_sample_ids = Numo::Int32[*@core_sample_ids.flatten]
+        nil
+      end
+
+      def expand_cluster(x, query_id, cluster_id)
+        target_ids = region_query(x[query_id, true], x)
+        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(x[m, true], x)
+            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(query, targets)
+        distance_arr = PairwiseMetric.euclidean_distance(query.expand_dims(0), targets)[0, true]
+        distance_arr.lt(@params[:eps]).where.to_a
+      end
+    end
+  end
+end

data/lib/rumale/clustering/k_means.rb

@@ -0,0 +1,138 @@
+# frozen_string_literal: true
+
+require 'rumale/base/base_estimator'
+require 'rumale/base/cluster_analyzer'
+require 'rumale/pairwise_metric'
+
+module Rumale
+  # This module consists of classes that implement cluster analysis methods.
+  module Clustering
+    # KMeans is a class that implements K-Means cluster analysis.
+    # The current implementation uses the Euclidean distance for analyzing the clusters.
+    #
+    # @example
+    #   analyzer = Rumale::Clustering::KMeans.new(n_clusters: 10, max_iter: 50)
+    #   cluster_labels = analyzer.fit_predict(samples)
+    #
+    # *Reference*
+    # - D. Arthur and S. Vassilvitskii, "k-means++: the advantages of careful seeding," Proc. SODA'07, pp. 1027--1035, 2007.
+    class KMeans
+      include Base::BaseEstimator
+      include Base::ClusterAnalyzer
+
+      # Return the centroids.
+      # @return [Numo::DFloat] (shape: [n_clusters, n_features])
+      attr_reader :cluster_centers
+
+      # Return the random generator.
+      # @return [Random]
+      attr_reader :rng
+
+      # Create a new cluster analyzer with K-Means method.
+      #
+      # @param n_clusters [Integer] The number of clusters.
+      # @param init [String] The initialization method for centroids ('random' or 'k-means++').
+      # @param max_iter [Integer] The maximum number of iterations.
+      # @param tol [Float] The tolerance of termination criterion.
+      # @param random_seed [Integer] The seed value using to initialize the random generator.
+      def initialize(n_clusters: 8, init: 'k-means++', max_iter: 50, tol: 1.0e-4, random_seed: nil)
+        check_params_integer(n_clusters: n_clusters, max_iter: max_iter)
+        check_params_float(tol: tol)
+        check_params_string(init: init)
+        check_params_type_or_nil(Integer, 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[:max_iter] = max_iter
+        @params[:tol] = tol
+        @params[:random_seed] = random_seed
+        @params[:random_seed] ||= srand
+        @cluster_centers = nil
+        @rng = Random.new(@params[:random_seed])
+      end
+
+      # Analysis clusters with given training data.
+      #
+      # @overload fit(x) -> KMeans
+      #
+      # @param x [Numo::DFloat] (shape: [n_samples, n_features]) The training data to be used for cluster analysis.
+      # @return [KMeans] The learned cluster analyzer itself.
+      def fit(x, _y = nil)
+        check_sample_array(x)
+        init_cluster_centers(x)
+        @params[:max_iter].times do |_t|
+          cluster_labels = assign_cluster(x)
+          old_centers = @cluster_centers.dup
+          @params[:n_clusters].times do |n|
+            assigned_bits = cluster_labels.eq(n)
+            @cluster_centers[n, true] = x[assigned_bits.where, true].mean(axis: 0) if assigned_bits.count.positive?
+          end
+          error = Numo::NMath.sqrt(((old_centers - @cluster_centers)**2).sum(axis: 1)).mean
+          break if error <= @params[:tol]
+        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)
+        check_sample_array(x)
+        assign_cluster(x)
+      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)
+        check_sample_array(x)
+        fit(x)
+        predict(x)
+      end
+
+      # Dump marshal data.
+      # @return [Hash] The marshal data.
+      def marshal_dump
+        { params: @params,
+          cluster_centers: @cluster_centers,
+          rng: @rng }
+      end
+
+      # Load marshal data.
+      # @return [nil]
+      def marshal_load(obj)
+        @params = obj[:params]
+        @cluster_centers = obj[:cluster_centers]
+        @rng = obj[:rng]
+        nil
+      end
+
+      private
+
+      def assign_cluster(x)
+        distance_matrix = PairwiseMetric.euclidean_distance(x, @cluster_centers)
+        distance_matrix.min_index(axis: 1) - Numo::Int32[*0.step(distance_matrix.size - 1, @cluster_centers.shape[0])]
+      end
+
+      def init_cluster_centers(x)
+        # random initialize
+        n_samples = x.shape[0]
+        rand_id = [*0...n_samples].sample(@params[:n_clusters], random: @rng)
+        @cluster_centers = x[rand_id, true].dup
+        return unless @params[:init] == 'k-means++'
+        # k-means++ initialize
+        (1...@params[:n_clusters]).each do |n|
+          distance_matrix = PairwiseMetric.euclidean_distance(x, @cluster_centers[0...n, true])
+          min_distances = distance_matrix.flatten[distance_matrix.min_index(axis: 1)]
+          probs = min_distances**2 / (min_distances**2).sum
+          cum_probs = probs.cumsum
+          selected_id = cum_probs.gt(@rng.rand).where.to_a.first
+          @cluster_centers[n, true] = x[selected_id, true].dup
+        end
+      end
+    end
+  end
+end