rumale-preprocessing 0.24.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 5e6ea7b493b3ea7d2eaeb8e4782e0dbdb79a265691b6e26f66786e713f2ad305
+  data.tar.gz: 4888e8622e364a8e5f62b595e43e32f72d41ed39ef2abb8b3fe79d0063191dc3
+SHA512:
+  metadata.gz: 0b9937675f98ff5f3c7cb8e16b6c56ad0613267b6383eb766ef14f26d1eeeb06539d1621a43b4391a13e54a2732f58d92fcf3212953ba170e886baa19580b7bb
+  data.tar.gz: eabf752b7c17d32fc075fb27d146e81efe766a33c4d12650605cebac2cbd7eefca8bb0f15324163e70432db189c20b6ef1e64867c81ed53fd1011d565e539076

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::Preprocessing
+
+[![Gem Version](https://badge.fury.io/rb/rumale-preprocessing.svg)](https://badge.fury.io/rb/rumale-preprocessing)
+[![BSD 3-Clause License](https://img.shields.io/badge/License-BSD%203--Clause-orange.svg)](https://github.com/yoshoku/rumale/blob/main/rumale-preprocessing/LICENSE.txt)
+[![Documentation](https://img.shields.io/badge/api-reference-blue.svg)](https://yoshoku.github.io/rumale/doc/Rumale/Preprocessing.html)
+
+Rumale is a machine learning library in Ruby.
+Rumale::Preprocessing provides preprocessing techniques,
+such as L2 normalization, standard scaling, and one-hot encoding,
+with Rumale interface.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'rumale-preprocessing'
+```
+
+And then execute:
+
+    $ bundle install
+
+Or install it yourself as:
+
+    $ gem install rumale-preprocessing
+
+## Documentation
+
+- [Rumale API Documentation - Preprocessing](https://yoshoku.github.io/rumale/doc/Rumale/Preprocessing.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/preprocessing/bin_discretizer.rb

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+require 'rumale/base/estimator'
+require 'rumale/base/transformer'
+require 'rumale/validation'
+
+module Rumale
+  module Preprocessing
+    # Discretizes features with a given number of bins.
+    # In some cases, discretizing features may accelerate decision tree training.
+    #
+    # @example
+    #   require 'rumale/preprocessing/bin_discretizer'
+    #
+    #   discretizer = Rumale::Preprocessing::BinDiscretizer.new(n_bins: 4)
+    #   samples = Numo::DFloat.new(5, 2).rand - 0.5
+    #   transformed = discretizer.fit_transform(samples)
+    #   # > pp samples
+    #   # Numo::DFloat#shape=[5,2]
+    #   # [[-0.438246, -0.126933],
+    #   #  [ 0.294815, -0.298958],
+    #   #  [-0.383959, -0.155968],
+    #   #  [ 0.039948,  0.237815],
+    #   #  [-0.334911, -0.449117]]
+    #   # > pp transformed
+    #   # Numo::DFloat#shape=[5,2]
+    #   # [[0, 1],
+    #   #  [3, 0],
+    #   #  [0, 1],
+    #   #  [2, 3],
+    #   #  [0, 0]]
+    class BinDiscretizer < ::Rumale::Base::Estimator
+      include ::Rumale::Base::Transformer
+
+      # Return the feature steps to be used discretizing.
+      # @return [Array<Numo::DFloat>] (shape: [n_features, n_bins])
+      attr_reader :feature_steps
+
+      # Create a new discretizer for features with given number of bins.
+      #
+      # @param n_bins [Integer] The number of bins to be used disretizing feature values.
+      def initialize(n_bins: 32)
+        super()
+        @params = { n_bins: n_bins }
+      end
+
+      # Fit feature ranges to be discretized.
+      #
+      # @overload fit(x) -> BinDiscretizer
+      #
+      # @param x [Numo::DFloat] (shape: [n_samples, n_features]) The samples to calculate the feature ranges.
+      # @return [BinDiscretizer]
+      def fit(x, _y = nil)
+        x = ::Rumale::Validation.check_convert_sample_array(x)
+
+        n_features = x.shape[1]
+        max_vals = x.max(0)
+        min_vals = x.min(0)
+        @feature_steps = Array.new(n_features) do |n|
+          Numo::DFloat.linspace(min_vals[n], max_vals[n], @params[:n_bins] + 1)[0...@params[:n_bins]]
+        end
+        self
+      end
+
+      # Fit feature ranges to be discretized, then return discretized samples.
+      #
+      # @overload fit_transform(x) -> Numo::DFloat
+      #
+      # @param x [Numo::DFloat] (shape: [n_samples, n_features]) The samples to be discretized.
+      # @return [Numo::DFloat] The discretized samples.
+      def fit_transform(x, _y = nil)
+        x = ::Rumale::Validation.check_convert_sample_array(x)
+
+        fit(x).transform(x)
+      end
+
+      # Peform discretizing the given samples.
+      #
+      # @param x [Numo::DFloat] (shape: [n_samples, n_features]) The samples to be discretized.
+      # @return [Numo::DFloat] The discretized samples.
+      def transform(x)
+        x = ::Rumale::Validation.check_convert_sample_array(x)
+
+        n_samples, n_features = x.shape
+        transformed = Numo::DFloat.zeros(n_samples, n_features)
+        n_features.times do |n|
+          steps = @feature_steps[n]
+          @params[:n_bins].times do |bin|
+            mask = x[true, n].ge(steps[bin]).where
+            transformed[mask, n] = bin
+          end
+        end
+        transformed
+      end
+    end
+  end
+end

data/lib/rumale/preprocessing/binarizer.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+require 'rumale/base/estimator'
+require 'rumale/base/transformer'
+require 'rumale/validation'
+
+module Rumale
+  module Preprocessing
+    # Binarize samples according to a threshold
+    #
+    # @example
+    #   require 'rumale/preprocessing/binarizer'
+    #
+    #   binarizer = Rumale::Preprocessing::Binarizer.new
+    #   x = Numo::DFloat[[-1.2, 3.2], [2.4, -0.5], [4.5, 0.8]]
+    #   b = binarizer.transform(x)
+    #   p b
+    #
+    #   # Numo::DFloat#shape=[3, 2]
+    #   # [[0, 1],
+    #   #  [1, 0],
+    #   #  [1, 1]]
+    class Binarizer < ::Rumale::Base::Estimator
+      include ::Rumale::Base::Transformer
+
+      # Create a new transformer for binarization.
+      # @param threshold [Float] The threshold value for binarization.
+      def initialize(threshold: 0.0)
+        super()
+        @params = { threshold: threshold }
+      end
+
+      # This method does nothing and returns the object itself.
+      # For compatibility with other transformer, this method exists.
+      #
+      # @overload fit() -> Binarizer
+      #
+      # @return [Binarizer]
+      def fit(_x = nil, _y = nil)
+        self
+      end
+
+      # Binarize each sample.
+      #
+      # @param x [Numo::DFloat] (shape: [n_samples, n_features]) The samples to be binarized.
+      # @return [Numo::DFloat] The binarized samples.
+      def transform(x)
+        x = ::Rumale::Validation.check_convert_sample_array(x)
+
+        x.class.cast(x.gt(@params[:threshold]))
+      end
+
+      # The output of this method is the same as that of the transform method.
+      # For compatibility with other transformer, this method exists.
+      #
+      # @param x [Numo::DFloat] (shape: [n_samples, n_features]) The samples to be binarized.
+      # @return [Numo::DFloat] The binarized samples.
+      def fit_transform(x, _y = nil)
+        x = ::Rumale::Validation.check_convert_sample_array(x)
+
+        fit(x).transform(x)
+      end
+    end
+  end
+end

data/lib/rumale/preprocessing/kernel_calculator.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+require 'rumale/base/estimator'
+require 'rumale/base/transformer'
+require 'rumale/pairwise_metric'
+require 'rumale/validation'
+
+module Rumale
+  module Preprocessing
+    # KernelCalculator is a class that calculates the kernel matrix with training data.
+    #
+    # @example
+    #   require 'rumale/preprocessing/kernel_calculator'
+    #   require 'rumale/kernel_machine/kernel_ridge'
+    #   require 'rumale/pipeline/pipeline'
+    #
+    #   transformer = Rumale::Preprocessing::KernelCalculator.new(kernel: 'rbf', gamma: 0.5)
+    #   regressor = Rumale::KernelMachine::KernelRidge.new
+    #   pipeline = Rumale::Pipeline::Pipeline.new(
+    #     steps: { trs: transfomer, est: regressor }
+    #   )
+    #   pipeline.fit(x_train, y_train)
+    #   results = pipeline.predict(x_test)
+    class KernelCalculator < ::Rumale::Base::Estimator
+      include ::Rumale::Base::Transformer
+
+      # Returns the training data for calculating kernel matrix.
+      # @return [Numo::DFloat] (shape: n_components, n_features)
+      attr_reader :components
+
+      # Create a new transformer that transforms feature vectors into a kernel matrix.
+      #
+      # @param kernel [String] The type of kernel function ('rbf', 'linear', 'poly', and 'sigmoid').
+      # @param gamma [Float] The gamma parameter in rbf/poly/sigmoid kernel function.
+      # @param degree [Integer] The degree parameter in polynomial kernel function.
+      # @param coef [Float] The coefficient in poly/sigmoid kernel function.
+      def initialize(kernel: 'rbf', gamma: 1, degree: 3, coef: 1)
+        super()
+        @params = {
+          kernel: kernel,
+          gamma: gamma,
+          degree: degree,
+          coef: coef
+        }
+      end
+
+      # Fit the model with given training data.
+      #
+      # @overload fit(x) -> KernelCalculator
+      #   @param x [Numo::NArray] (shape: [n_samples, n_features]) The training data to be used for calculating kernel matrix.
+      # @return [KernelCalculator] The learned transformer itself.
+      def fit(x, _y = nil)
+        x = ::Rumale::Validation.check_convert_sample_array(x)
+
+        @components = x.dup
+        self
+      end
+
+      # Fit the model with training data, and then transform them with the learned model.
+      #
+      # @overload fit_transform(x) -> Numo::DFloat
+      #   @param x [Numo::DFloat] (shape: [n_samples, n_features]) The training data to be used for calculating kernel matrix.
+      # @return [Numo::DFloat] (shape: [n_samples, n_samples]) The calculated kernel matrix.
+      def fit_transform(x, y = nil)
+        x = ::Rumale::Validation.check_convert_sample_array(x)
+
+        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 used for calculating kernel matrix with the training data.
+      # @return [Numo::DFloat] (shape: [n_samples, n_components]) The calculated kernel matrix.
+      def transform(x)
+        x = ::Rumale::Validation.check_convert_sample_array(x)
+
+        kernel_mat(x, @components)
+      end
+
+      private
+
+      def kernel_mat(x, y)
+        case @params[:kernel]
+        when 'rbf'
+          ::Rumale::PairwiseMetric.rbf_kernel(x, y, @params[:gamma])
+        when 'poly'
+          ::Rumale::PairwiseMetric.polynomial_kernel(x, y, @params[:degree], @params[:gamma], @params[:coef])
+        when 'sigmoid'
+          ::Rumale::PairwiseMetric.sigmoid_kernel(x, y, @params[:gamma], @params[:coef])
+        when 'linear'
+          ::Rumale::PairwiseMetric.linear_kernel(x, y)
+        else
+          raise ArgumentError, "Expect kernel parameter to be given 'rbf', 'linear', 'poly', or 'sigmoid'."
+        end
+      end
+    end
+  end
+end

data/lib/rumale/preprocessing/l1_normalizer.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+require 'rumale/base/estimator'
+require 'rumale/base/transformer'
+require 'rumale/validation'
+
+module Rumale
+  module Preprocessing
+    # Normalize samples to unit L1-norm.
+    #
+    # @example
+    #   require 'rumale/preprocessing/l1_normalizer'
+    #
+    #   normalizer = Rumale::Preprocessing::L1Normalizer.new
+    #   new_samples = normalizer.fit_transform(samples)
+    class L1Normalizer < ::Rumale::Base::Estimator
+      include ::Rumale::Base::Transformer
+
+      # Return the vector consists of L1-norm for each sample.
+      # @return [Numo::DFloat] (shape: [n_samples])
+      attr_reader :norm_vec # :nodoc:
+
+      # Create a new normalizer for normaliing to L1-norm.
+      def initialize # rubocop:disable Lint/UselessMethodDefinition
+        super()
+      end
+
+      # Calculate L1-norms of each sample.
+      #
+      # @overload fit(x) -> L1Normalizer
+      #
+      # @param x [Numo::DFloat] (shape: [n_samples, n_features]) The samples to calculate L1-norms.
+      # @return [L1Normalizer]
+      def fit(x, _y = nil)
+        x = ::Rumale::Validation.check_convert_sample_array(x)
+
+        @norm_vec = x.abs.sum(axis: 1)
+        @norm_vec[@norm_vec.eq(0)] = 1
+        self
+      end
+
+      # Calculate L1-norms of each sample, and then normalize samples to L1-norm.
+      #
+      # @overload fit_transform(x) -> Numo::DFloat
+      #
+      # @param x [Numo::DFloat] (shape: [n_samples, n_features]) The samples to calculate L1-norms.
+      # @return [Numo::DFloat] The normalized samples.
+      def fit_transform(x, _y = nil)
+        x = ::Rumale::Validation.check_convert_sample_array(x)
+
+        fit(x)
+        x / @norm_vec.expand_dims(1)
+      end
+
+      # Calculate L1-norms of each sample, and then normalize samples to L1-norm.
+      # This method calls the fit_transform method. This method exists for the Pipeline class.
+      #
+      # @param x [Numo::DFloat] (shape: [n_samples, n_features]) The samples to calculate L1-norms.
+      # @return [Numo::DFloat] The normalized samples.
+      def transform(x)
+        x = ::Rumale::Validation.check_convert_sample_array(x)
+
+        fit_transform(x)
+      end
+    end
+  end
+end

data/lib/rumale/preprocessing/l2_normalizer.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+require 'rumale/base/estimator'
+require 'rumale/base/transformer'
+require 'rumale/validation'
+
+module Rumale
+  # This module consists of the classes that perform preprocessings.
+  module Preprocessing
+    # Normalize samples to unit L2-norm.
+    #
+    # @example
+    #   require 'rumale/preprocessing/l2_normalizer'
+    #
+    #   normalizer = Rumale::Preprocessing::L2Normalizer.new
+    #   new_samples = normalizer.fit_transform(samples)
+    class L2Normalizer < ::Rumale::Base::Estimator
+      include ::Rumale::Base::Transformer
+
+      # Return the vector consists of L2-norm for each sample.
+      # @return [Numo::DFloat] (shape: [n_samples])
+      attr_reader :norm_vec # :nodoc:
+
+      # Create a new normalizer for normaliing to unit L2-norm.
+      def initialize # rubocop:disable Lint/UselessMethodDefinition
+        super()
+      end
+
+      # Calculate L2-norms of each sample.
+      #
+      # @overload fit(x) -> L2Normalizer
+      #
+      # @param x [Numo::DFloat] (shape: [n_samples, n_features]) The samples to calculate L2-norms.
+      # @return [L2Normalizer]
+      def fit(x, _y = nil)
+        x = ::Rumale::Validation.check_convert_sample_array(x)
+
+        @norm_vec = Numo::NMath.sqrt((x**2).sum(axis: 1))
+        @norm_vec[@norm_vec.eq(0)] = 1
+        self
+      end
+
+      # Calculate L2-norms of each sample, and then normalize samples to unit L2-norm.
+      #
+      # @overload fit_transform(x) -> Numo::DFloat
+      #
+      # @param x [Numo::DFloat] (shape: [n_samples, n_features]) The samples to calculate L2-norms.
+      # @return [Numo::DFloat] The normalized samples.
+      def fit_transform(x, _y = nil)
+        x = ::Rumale::Validation.check_convert_sample_array(x)
+
+        fit(x)
+        x / @norm_vec.expand_dims(1)
+      end
+
+      # Calculate L2-norms of each sample, and then normalize samples to unit L2-norm.
+      # This method calls the fit_transform method. This method exists for the Pipeline class.
+      #
+      # @param x [Numo::DFloat] (shape: [n_samples, n_features]) The samples to calculate L2-norms.
+      # @return [Numo::DFloat] The normalized samples.
+      def transform(x)
+        x = ::Rumale::Validation.check_convert_sample_array(x)
+
+        fit_transform(x)
+      end
+    end
+  end
+end

data/lib/rumale/preprocessing/label_binarizer.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+require 'rumale/base/estimator'
+require 'rumale/base/transformer'
+
+module Rumale
+  module Preprocessing
+    # Encode labels to binary labels with one-vs-all scheme.
+    #
+    # @example
+    #   require 'rumale/preprocessing/label_binarizer'
+    #
+    #   encoder = Rumale::Preprocessing::LabelBinarizer.new
+    #   label = [0, -1, 3, 3, 1, 1]
+    #   p encoder.fit_transform(label)
+    #   # Numo::Int32#shape=[6,4]
+    #   # [[0, 1, 0, 0],
+    #   #  [1, 0, 0, 0],
+    #   #  [0, 0, 0, 1],
+    #   #  [0, 0, 0, 1],
+    #   #  [0, 0, 1, 0],
+    #   #  [0, 0, 1, 0]]
+    class LabelBinarizer < ::Rumale::Base::Estimator
+      include ::Rumale::Base::Transformer
+
+      # Return the class labels.
+      # @return [Array] (size: [n_classes])
+      attr_reader :classes
+
+      # Create a new encoder for binarizing labels with one-vs-all scheme.
+      #
+      # @param neg_label [Integer] The value represents negative label.
+      # @param pos_label [Integer] The value represents positive label.
+      def initialize(neg_label: 0, pos_label: 1)
+        super()
+        @params = {
+          neg_label: neg_label,
+          pos_label: pos_label
+        }
+      end
+
+      # Fit encoder to labels.
+      #
+      # @overload fit(y) -> LabelBinarizer
+      #   @param y [Numo::NArray/Array] (shape: [n_samples]) The labels to fit encoder.
+      # @return [LabelBinarizer]
+      def fit(y, _not_used = nil)
+        y = y.to_a if y.is_a?(Numo::NArray)
+        @classes = y.uniq.sort
+        self
+      end
+
+      # Fit encoder to labels, then return binarized labels.
+      #
+      # @overload fit_transform(y) -> Numo::DFloat
+      #   @param y [Numo::NArray/Array] (shape: [n_samples]) The labels to fit encoder.
+      # @return [Numo::Int32] (shape: [n_samples, n_classes]) The binarized labels.
+      def fit_transform(y, _not_used = nil)
+        y = y.to_a if y.is_a?(Numo::NArray)
+        fit(y).transform(y)
+      end
+
+      # Encode labels.
+      #
+      # @param y [Array] (shape: [n_samples]) The labels to be encoded.
+      # @return [Numo::Int32] (shape: [n_samples, n_classes]) The binarized labels.
+      def transform(y)
+        y = y.to_a if y.is_a?(Numo::NArray)
+        n_classes = @classes.size
+        n_samples = y.size
+        codes = Numo::Int32.zeros(n_samples, n_classes) + @params[:neg_label]
+        n_samples.times { |n| codes[n, @classes.index(y[n])] = @params[:pos_label] }
+        codes
+      end
+
+      # Decode binarized labels.
+      #
+      # @param x [Numo::Int32] (shape: [n_samples, n_classes]) The binarized labels to be decoded.
+      # @return [Array] (shape: [n_samples]) The decoded labels.
+      def inverse_transform(x)
+        n_samples = x.shape[0]
+        Array.new(n_samples) { |n| @classes[x[n, true].ne(@params[:neg_label]).where[0]] }
+      end
+    end
+  end
+end

data/lib/rumale/preprocessing/label_encoder.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+require 'rumale/base/estimator'
+require 'rumale/base/transformer'
+
+module Rumale
+  module Preprocessing
+    # Encode labels to values between 0 and n_classes - 1.
+    #
+    # @example
+    #   require 'rumale/preprocessing/label_encoder'
+    #
+    #   encoder = Rumale::Preprocessing::LabelEncoder.new
+    #   labels = Numo::Int32[1, 8, 8, 15, 0]
+    #   encoded_labels = encoder.fit_transform(labels)
+    #   # > pp encoded_labels
+    #   # Numo::Int32#shape=[5]
+    #   # [1, 2, 2, 3, 0]
+    #   decoded_labels = encoder.inverse_transform(encoded_labels)
+    #   # > pp decoded_labels
+    #   # [1, 8, 8, 15, 0]
+    class LabelEncoder < ::Rumale::Base::Estimator
+      include ::Rumale::Base::Transformer
+
+      # Return the class labels.
+      # @return [Array] (size: [n_classes])
+      attr_reader :classes
+
+      # Create a new encoder for encoding labels to values between 0 and n_classes - 1.
+      def initialize # rubocop:disable Lint/UselessMethodDefinition
+        super()
+      end
+
+      # Fit label-encoder to labels.
+      #
+      # @overload fit(x) -> LabelEncoder
+      #
+      # @param x [Array] (shape: [n_samples]) The labels to fit label-encoder.
+      # @return [LabelEncoder]
+      def fit(x, _y = nil)
+        x = x.to_a if x.is_a?(Numo::NArray)
+        @classes = x.sort.uniq
+        self
+      end
+
+      # Fit label-encoder to labels, then return encoded labels.
+      #
+      # @overload fit_transform(x) -> Numo::DFloat
+      #
+      # @param x [Array] (shape: [n_samples]) The labels to fit label-encoder.
+      # @return [Numo::Int32] The encoded labels.
+      def fit_transform(x, _y = nil)
+        x = x.to_a if x.is_a?(Numo::NArray)
+        fit(x).transform(x)
+      end
+
+      # Encode labels.
+      #
+      # @param x [Array] (shape: [n_samples]) The labels to be encoded.
+      # @return [Numo::Int32] The encoded labels.
+      def transform(x)
+        x = x.to_a if x.is_a?(Numo::NArray)
+        Numo::Int32[*(x.map { |v| @classes.index(v) })]
+      end
+
+      # Decode encoded labels.
+      #
+      # @param x [Numo::Int32] (shape: [n_samples]) The labels to be decoded.
+      # @return [Array] The decoded labels.
+      def inverse_transform(x)
+        x.to_a.map { |n| @classes[n] }
+      end
+    end
+  end
+end