rumale-pipeline 0.24.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: cd3ec61c4a23cd7022d5be945e4bd22dadbdb883e6800a7d5e2026b05e6c5cf0
+  data.tar.gz: a6be2df1a40c169dd46a5b587df6314ab438c507c5bd721d802a422dfcd66bea
+SHA512:
+  metadata.gz: 8ebc9359645c3e8300e6eb797c9ecbb2da7f99b77522e44d8619562ad3ffcdde681e1ed9256fb7fe5882d36a6c67ccf6c6f6386ee5f0f68a801cc16208305845
+  data.tar.gz: 14d7861bb9e31aba0924f021f320dc1c0d44e7880f9bdd03e465f3b3bc9d26132bce259317a96f3644f1c9bf753b6896e9fcd6727882c8ad3d01078eea62f842

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,33 @@
+# Rumale::Pipeline
+
+[![Gem Version](https://badge.fury.io/rb/rumale-pipeline.svg)](https://badge.fury.io/rb/rumale-pipeline)
+[![BSD 3-Clause License](https://img.shields.io/badge/License-BSD%203--Clause-orange.svg)](https://github.com/yoshoku/rumale/blob/main/rumale-pipeline/LICENSE.txt)
+[![Documentation](https://img.shields.io/badge/api-reference-blue.svg)](https://yoshoku.github.io/rumale/doc/Rumale/Pipeline.html)
+
+Rumale is a machine learning library in Ruby.
+Rumale::Pipeline provides classes for chaining transformers and estimators
+with Rumale interface.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'rumale-pipeline'
+```
+
+And then execute:
+
+    $ bundle install
+
+Or install it yourself as:
+
+    $ gem install rumale-pipeline
+
+## Documentation
+
+- [Rumale API Documentation - Pipeline](https://yoshoku.github.io/rumale/doc/Rumale/Pipeline.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/pipeline/feature_union.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+require 'rumale/base/estimator'
+
+module Rumale
+  module Pipeline
+    # FeatureUnion is a class that implements the function concatenating the multi-transformer results.
+    #
+    # @example
+    #   require 'rumale/kernel_approximation/rbf'
+    #   require 'rumale/decomposition/pca'
+    #   require 'rumale/pipeline/feature_union'
+    #
+    #   fu = Rumale::Pipeline::FeatureUnion.new(
+    #     transformers: {
+    #       'rbf': Rumale::KernelApproximation::RBF.new(gamma: 1.0, n_components: 96, random_seed: 1),
+    #       'pca': Rumale::Decomposition::PCA.new(n_components: 32)
+    #     }
+    #   )
+    #   fu.fit(training_samples, traininig_labels)
+    #   results = fu.predict(testing_samples)
+    #
+    #   # > p results.shape[1]
+    #   # > 128
+    #
+    class FeatureUnion < ::Rumale::Base::Estimator
+      # Return the transformers
+      # @return [Hash]
+      attr_reader :transformers
+
+      # Create a new feature union.
+      #
+      # @param transformers [Hash] List of transformers.  The order of transforms follows the insertion order of hash keys.
+      def initialize(transformers:)
+        super()
+        @params = {}
+        @transformers = transformers
+      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 transformers.
+      # @param y [Numo::NArray/Nil] (shape: [n_samples, n_outputs]) The target values or labels to be used for fitting the transformers.
+      # @return [FeatureUnion] The learned feature union itself.
+      def fit(x, y = nil)
+        @transformers.each { |_k, t| t.fit(x, y) }
+        self
+      end
+
+      # Fit the model with training data, and then transform them with the learned model.
+      #
+      # @param x [Numo::DFloat] (shape: [n_samples, n_features]) The training data to be used for fitting the transformers.
+      # @param y [Numo::NArray/Nil] (shape: [n_samples, n_outputs]) The target values or labels to be used for fitting the transformers.
+      # @return [Numo::DFloat] (shape: [n_samples, sum_n_components]) The transformed and concatenated data.
+      def fit_transform(x, y = nil)
+        fit(x, y).transform(x)
+      end
+
+      # Transform the given data with the learned model.
+      #
+      # @param x [Numo::DFloat] (shape: [n_samples, n_features]) The data to be transformed with the learned transformers.
+      # @return [Numo::DFloat] (shape: [n_samples, sum_n_components]) The transformed and concatenated data.
+      def transform(x)
+        z = @transformers.values.map { |t| t.transform(x) }
+        Numo::NArray.hstack(z)
+      end
+    end
+  end
+end

data/lib/rumale/pipeline/pipeline.rb

@@ -0,0 +1,175 @@
+# frozen_string_literal: true
+
+require 'rumale/base/estimator'
+
+module Rumale
+  # Module implements utilities of pipeline that cosists of a chain of transfomers and estimators.
+  module Pipeline
+    # Pipeline is a class that implements the function to perform the transformers and estimators sequencially.
+    #
+    # @example
+    #   require 'rumale/kernel_approximation/rbf'
+    #   require 'rumale/linear_model/svc'
+    #   require 'rumale/pipeline/pipeline'
+    #
+    #   rbf = Rumale::KernelApproximation::RBF.new(gamma: 1.0, n_components: 128, random_seed: 1)
+    #   svc = Rumale::LinearModel::SVC.new(reg_param: 1.0, fit_bias: true, max_iter: 5000, random_seed: 1)
+    #   pipeline = Rumale::Pipeline::Pipeline.new(steps: { trs: rbf, est: svc })
+    #   pipeline.fit(training_samples, traininig_labels)
+    #   results = pipeline.predict(testing_samples)
+    #
+    class Pipeline < ::Rumale::Base::Estimator
+      # Return the steps.
+      # @return [Hash]
+      attr_reader :steps
+
+      # Create a new pipeline.
+      #
+      # @param steps [Hash] List of transformers and estimators. The order of transforms follows the insertion order of hash keys.
+      #   The last entry is considered an estimator.
+      def initialize(steps:)
+        super()
+        validate_steps(steps)
+        @params = {}
+        @steps = steps
+      end
+
+      # Fit the model with given training data.
+      #
+      # @param x [Numo::DFloat] (shape: [n_samples, n_features]) The training data to be transformed and used for fitting the model.
+      # @param y [Numo::NArray] (shape: [n_samples, n_outputs]) The target values or labels to be used for fitting the model.
+      # @return [Pipeline] The learned pipeline itself.
+      def fit(x, y)
+        trans_x = apply_transforms(x, y, fit: true)
+        last_estimator&.fit(trans_x, y)
+        self
+      end
+
+      # Call the fit_predict method of last estimator after applying all transforms.
+      #
+      # @param x [Numo::DFloat] (shape: [n_samples, n_features]) The training data to be transformed and used for fitting the model.
+      # @param y [Numo::NArray] (shape: [n_samples, n_outputs], default: nil) The target values or labels to be used for fitting the model.
+      # @return [Numo::NArray] The predicted results by last estimator.
+      def fit_predict(x, y = nil)
+        trans_x = apply_transforms(x, y, fit: true)
+        last_estimator.fit_predict(trans_x)
+      end
+
+      # Call the fit_transform method of last estimator after applying all transforms.
+      #
+      # @param x [Numo::DFloat] (shape: [n_samples, n_features]) The training data to be transformed and used for fitting the model.
+      # @param y [Numo::NArray] (shape: [n_samples, n_outputs], default: nil) The target values or labels to be used for fitting the model.
+      # @return [Numo::NArray] The predicted results by last estimator.
+      def fit_transform(x, y = nil)
+        trans_x = apply_transforms(x, y, fit: true)
+        last_estimator.fit_transform(trans_x, y)
+      end
+
+      # Call the decision_function method of last estimator after applying all transforms.
+      #
+      # @param x [Numo::DFloat] (shape: [n_samples, n_features]) The samples to compute the scores.
+      # @return [Numo::DFloat] (shape: [n_samples]) Confidence score per sample.
+      def decision_function(x)
+        trans_x = apply_transforms(x)
+        last_estimator.decision_function(trans_x)
+      end
+
+      # Call the predict method of last estimator after applying all transforms.
+      #
+      # @param x [Numo::DFloat] (shape: [n_samples, n_features]) The samples to obtain prediction result.
+      # @return [Numo::NArray] The predicted results by last estimator.
+      def predict(x)
+        trans_x = apply_transforms(x)
+        last_estimator.predict(trans_x)
+      end
+
+      # Call the predict_log_proba method of last estimator after applying all transforms.
+      #
+      # @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)
+        trans_x = apply_transforms(x)
+        last_estimator.predict_log_proba(trans_x)
+      end
+
+      # Call the predict_proba method of last estimator after applying all transforms.
+      #
+      # @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)
+        trans_x = apply_transforms(x)
+        last_estimator.predict_proba(trans_x)
+      end
+
+      # Call the transform method of last estimator after applying all transforms.
+      #
+      # @param x [Numo::DFloat] (shape: [n_samples, n_features]) The samples to be transformed.
+      # @return [Numo::DFloat] (shape: [n_samples, n_components]) The transformed samples.
+      def transform(x)
+        trans_x = apply_transforms(x)
+        last_estimator.nil? ? trans_x : last_estimator.transform(trans_x)
+      end
+
+      # Call the inverse_transform method in reverse order.
+      #
+      # @param z [Numo::DFloat] (shape: [n_samples, n_components]) The transformed samples to be restored into original space.
+      # @return [Numo::DFloat] (shape: [n_samples, n_featuress]) The restored samples.
+      def inverse_transform(z)
+        itrans_z = z
+        @steps.keys.reverse_each do |name|
+          transformer = @steps[name]
+          next if transformer.nil?
+
+          itrans_z = transformer.inverse_transform(itrans_z)
+        end
+        itrans_z
+      end
+
+      # Call the score method of last estimator after applying all transforms.
+      #
+      # @param x [Numo::DFloat] (shape: [n_samples, n_features]) Testing data.
+      # @param y [Numo::NArray] (shape: [n_samples, n_outputs]) True target values or labels for testing data.
+      # @return [Float] The score of last estimator
+      def score(x, y)
+        trans_x = apply_transforms(x)
+        last_estimator.score(trans_x, y)
+      end
+
+      private
+
+      def validate_steps(steps)
+        steps.keys[0...-1].each do |name|
+          transformer = steps[name]
+          next if transformer.nil? || (transformer.class.method_defined?(:fit) && transformer.class.method_defined?(:transform))
+
+          raise TypeError,
+                'Class of intermediate step in pipeline should be implemented fit and transform methods: ' \
+                "#{name} => #{transformer.class}"
+        end
+
+        estimator = steps[steps.keys.last]
+        unless estimator.nil? || estimator.class.method_defined?(:fit) # rubocop:disable Style/GuardClause
+          raise TypeError,
+                'Class of last step in pipeline should be implemented fit method: ' \
+                "#{steps.keys.last} => #{estimator.class}"
+        end
+      end
+
+      def apply_transforms(x, y = nil, fit: false)
+        trans_x = x
+        @steps.keys[0...-1].each do |name|
+          transformer = @steps[name]
+          next if transformer.nil?
+
+          transformer.fit(trans_x, y) if fit
+          trans_x = transformer.transform(trans_x)
+        end
+        trans_x
+      end
+
+      def last_estimator
+        @steps[@steps.keys.last]
+      end
+    end
+  end
+end

data/lib/rumale/pipeline/version.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+# Rumale is a machine learning library in Ruby.
+module Rumale
+  # Module implements utilities of pipeline that cosists of a chain of transfomers and estimators.
+  module Pipeline
+    # @!visibility private
+    VERSION = '0.24.0'
+  end
+end

data/lib/rumale/pipeline.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+require 'numo/narray'
+
+require_relative 'pipeline/feature_union'
+require_relative 'pipeline/pipeline'
+require_relative 'pipeline/version'

metadata

@@ -0,0 +1,84 @@
+--- !ruby/object:Gem::Specification
+name: rumale-pipeline
+version: !ruby/object:Gem::Version
+  version: 0.24.0
+platform: ruby
+authors:
+- yoshoku
+autorequire:
+bindir: exe
+cert_chain: []
+date: 2022-12-31 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: numo-narray
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.9.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.9.1
+- !ruby/object:Gem::Dependency
+  name: rumale-core
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.24.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.24.0
+description: Rumale::Pipeline provides classes for chaining transformers and estimators
+  with Rumale interface.
+email:
+- yoshoku@outlook.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE.txt
+- README.md
+- lib/rumale/pipeline.rb
+- lib/rumale/pipeline/feature_union.rb
+- lib/rumale/pipeline/pipeline.rb
+- lib/rumale/pipeline/version.rb
+homepage: https://github.com/yoshoku/rumale
+licenses:
+- BSD-3-Clause
+metadata:
+  homepage_uri: https://github.com/yoshoku/rumale
+  source_code_uri: https://github.com/yoshoku/rumale/tree/main/rumale-pipeline
+  changelog_uri: https://github.com/yoshoku/rumale/blob/main/CHANGELOG.md
+  documentation_uri: https://yoshoku.github.io/rumale/doc/
+  rubygems_mfa_required: 'true'
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.3.26
+signing_key:
+specification_version: 4
+summary: Rumale::Pipeline provides classes for chaining transformers and estimators
+  with Rumale interface.
+test_files: []