rumale-metric_learning 0.24.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: de8906421117ba7ceb261e21f9a469cdda66c4a582acddef8b7c25d9e81b5b2c
+  data.tar.gz: 1f89eca43ee6a34c4bfecb3779d6b7e2ba210833834e46105ab9d56cfbe3ef91
+SHA512:
+  metadata.gz: 6cd556eb2d5060f16f766fae6595b3cf302723f38788ab67680ad053306642a86ef8745e100d387059cc304ad1f07cc9e7e6493bddaa6bc9e066c2ebda5c0772
+  data.tar.gz: 77afbc98ad84566a932193ddb3c774b5edff63a7b7747958cf651ecbff41c1826e0571e9f6232e5261520ecf7545c9e3e8195680ca1f18aff5506233d0d5b682

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

@@ -0,0 +1,118 @@
+# frozen_string_literal: true
+
+require 'rumale/base/estimator'
+require 'rumale/base/transformer'
+require 'rumale/validation'
+
+module Rumale
+  module MetricLearning
+    # FisherDiscriminantAnalysis is a class that implements Fisher Discriminant Analysis.
+    #
+    # @example
+    #   require 'rumale/metric_learning/fisher_discriminant_analysis'
+    #
+    #   transformer = Rumale::MetricLearning::FisherDiscriminantAnalysis.new
+    #   transformer.fit(training_samples, traininig_labels)
+    #   low_samples = transformer.transform(testing_samples)
+    #
+    # *Reference*
+    # - Fisher, R. A., "The use of multiple measurements in taxonomic problems," Annals of Eugenics, vol. 7, pp. 179--188, 1936.
+    # - Sugiyama, M., "Local Fisher Discriminant Analysis for Supervised Dimensionality Reduction," Proc. ICML'06, pp. 905--912, 2006.
+    class FisherDiscriminantAnalysis < ::Rumale::Base::Estimator
+      include ::Rumale::Base::Transformer
+
+      # Returns the transform matrix.
+      # @return [Numo::DFloat] (shape: [n_components, n_features])
+      attr_reader :components
+
+      # Returns the mean vector.
+      # @return [Numo::DFloat] (shape: [n_features])
+      attr_reader :mean
+
+      # Returns the class mean vectors.
+      # @return [Numo::DFloat] (shape: [n_classes, n_features])
+      attr_reader :class_means
+
+      # Return the class labels.
+      # @return [Numo::Int32] (shape: [n_classes])
+      attr_reader :classes
+
+      # Create a new transformer with FisherDiscriminantAnalysis.
+      #
+      # @param n_components [Integer] The number of components.
+      #   If nil is given, the number of components will be set to [n_features, n_classes - 1].min
+      def initialize(n_components: nil)
+        super()
+        @params = { n_components: n_components }
+      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 labels to be used for fitting the model.
+      # @return [FisherDiscriminantAnalysis] The learned classifier itself.
+      def fit(x, y)
+        x = ::Rumale::Validation.check_convert_sample_array(x)
+        y = ::Rumale::Validation.check_convert_label_array(y)
+        ::Rumale::Validation.check_sample_size(x, y)
+        unless enable_linalg?(warning: false)
+          raise 'FisherDiscriminatAnalysis#fit requires Numo::Linalg but that is not loaded.'
+        end
+
+        # initialize some variables.
+        n_features = x.shape[1]
+        @classes = Numo::Int32[*y.to_a.uniq.sort]
+        n_classes = @classes.size
+        n_components = if @params[:n_components].nil?
+                         [n_features, n_classes - 1].min
+                       else
+                         [n_features, @params[:n_components]].min
+                       end
+
+        # calculate within and between scatter matricies.
+        within_mat = Numo::DFloat.zeros(n_features, n_features)
+        between_mat = Numo::DFloat.zeros(n_features, n_features)
+        @class_means = Numo::DFloat.zeros(n_classes, n_features)
+        @mean = x.mean(0)
+        @classes.each_with_index do |label, i|
+          mask_vec = y.eq(label)
+          sz_class = mask_vec.count
+          class_samples = x[mask_vec, true]
+          class_mean = class_samples.mean(0)
+          within_mat += (class_samples - class_mean).transpose.dot(class_samples - class_mean)
+          between_mat += sz_class * (class_mean - @mean).expand_dims(1) * (class_mean - @mean)
+          @class_means[i, true] = class_mean
+        end
+
+        # calculate components.
+        _, evecs = Numo::Linalg.eigh(between_mat, within_mat, vals_range: (n_features - n_components)...n_features)
+        comps = evecs.reverse(1).transpose.dup
+        @components = n_components == 1 ? comps[0, true].dup : comps.dup
+        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 model.
+      # @param y [Numo::Int32] (shape: [n_samples]) The labels to be used for fitting the model.
+      # @return [Numo::DFloat] (shape: [n_samples, n_components]) The transformed data
+      def fit_transform(x, y)
+        x = ::Rumale::Validation.check_convert_sample_array(x)
+        y = ::Rumale::Validation.check_convert_label_array(y)
+        ::Rumale::Validation.check_sample_size(x, y)
+
+        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 model.
+      # @return [Numo::DFloat] (shape: [n_samples, n_components]) The transformed data.
+      def transform(x)
+        x = ::Rumale::Validation.check_convert_sample_array(x)
+
+        x.dot(@components.transpose)
+      end
+    end
+  end
+end

data/lib/rumale/metric_learning/mlkr.rb

@@ -0,0 +1,162 @@
+# frozen_string_literal: true
+
+require 'lbfgsb'
+
+require 'rumale/base/estimator'
+require 'rumale/base/transformer'
+require 'rumale/decomposition/pca'
+require 'rumale/pairwise_metric'
+require 'rumale/utils'
+require 'rumale/validation'
+
+module Rumale
+  module MetricLearning
+    # MLKR is a class that implements Metric Learning for Kernel Regression.
+    #
+    # @example
+    #   require 'rumale/metric_learning/mlkr'
+    #
+    #   transformer = Rumale::MetricLearning::MLKR.new
+    #   transformer.fit(training_samples, traininig_target_values)
+    #   low_samples = transformer.transform(testing_samples)
+    #
+    # *Reference*
+    # - Weinberger, K. Q. and Tesauro, G., "Metric Learning for Kernel Regression," Proc. AISTATS'07, pp. 612--629, 2007.
+    class MLKR < ::Rumale::Base::Estimator
+      include ::Rumale::Base::Transformer
+
+      # Returns the metric components.
+      # @return [Numo::DFloat] (shape: [n_components, n_features])
+      attr_reader :components
+
+      # Return the number of iterations run for optimization
+      # @return [Integer]
+      attr_reader :n_iter
+
+      # Return the random generator.
+      # @return [Random]
+      attr_reader :rng
+
+      # Create a new transformer with MLKR.
+      #
+      # @param n_components [Integer] The number of components.
+      # @param init [String] The initialization method for components ('random' or 'pca').
+      # @param max_iter [Integer] The maximum number of iterations.
+      # @param tol [Float] The tolerance of termination criterion.
+      #   This value is given as tol / Lbfgsb::DBL_EPSILON to the factr argument of Lbfgsb.minimize method.
+      # @param verbose [Boolean] The flag indicating whether to output loss during iteration.
+      #   If true is given, 'iterate.dat' file is generated by lbfgsb.rb.
+      # @param random_seed [Integer] The seed value using to initialize the random generator.
+      def initialize(n_components: nil, init: 'random', max_iter: 100, tol: 1e-6, verbose: false, random_seed: nil)
+        super()
+        @params = {
+          n_components: n_components,
+          init: init,
+          max_iter: max_iter,
+          tol: tol,
+          verbose: verbose,
+          random_seed: random_seed || srand
+        }
+        @rng = Random.new(@params[:random_seed])
+      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::DFloat] (shape: [n_samples]) The target values to be used for fitting the model.
+      # @return [MLKR] The learned classifier itself.
+      def fit(x, y)
+        x = ::Rumale::Validation.check_convert_sample_array(x)
+        y = ::Rumale::Validation.check_convert_target_value_array(y)
+        ::Rumale::Validation.check_sample_size(x, y)
+
+        n_features = x.shape[1]
+        n_components = if @params[:n_components].nil?
+                         n_features
+                       else
+                         [n_features, @params[:n_components]].min
+                       end
+        @components, @n_iter = optimize_components(x, y, n_features, n_components)
+        @prototypes = x.dot(@components.transpose)
+        @values = 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 model.
+      # @param y [Numo::DFloat] (shape: [n_samples]) The target values to be used for fitting the model.
+      # @return [Numo::DFloat] (shape: [n_samples, n_components]) The transformed data
+      def fit_transform(x, y)
+        x = ::Rumale::Validation.check_convert_sample_array(x)
+        y = ::Rumale::Validation.check_convert_target_value_array(y)
+        ::Rumale::Validation.check_sample_size(x, y)
+
+        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 model.
+      # @return [Numo::DFloat] (shape: [n_samples, n_components]) The transformed data.
+      def transform(x)
+        x = ::Rumale::Validation.check_convert_sample_array(x)
+
+        x.dot(@components.transpose)
+      end
+
+      private
+
+      def init_components(x, n_features, n_components)
+        if @params[:init] == 'pca'
+          pca = ::Rumale::Decomposition::PCA.new(n_components: n_components)
+          pca.fit(x).components.flatten.dup
+        else
+          ::Rumale::Utils.rand_normal([n_features, n_components], @rng.dup).flatten.dup
+        end
+      end
+
+      def optimize_components(x, y, n_features, n_components)
+        # initialize components.
+        comp_init = init_components(x, n_features, n_components)
+        # initialize optimization results.
+        res = {}
+        res[:x] = comp_init
+        res[:n_iter] = 0
+        # perform optimization.
+        verbose = @params[:verbose] ? 1 : -1
+        res = Lbfgsb.minimize(
+          fnc: method(:mlkr_fnc), jcb: true, x_init: comp_init, args: [x, y],
+          maxiter: @params[:max_iter], factr: @params[:tol] / Lbfgsb::DBL_EPSILON, verbose: verbose
+        )
+        # return the results.
+        n_iter = res[:n_iter]
+        comps = n_components == 1 ? res[:x].dup : res[:x].reshape(n_components, n_features)
+        [comps, n_iter]
+      end
+
+      def mlkr_fnc(w, x, y)
+        # initialize some variables.
+        n_features = x.shape[1]
+        n_components = w.size / n_features
+        # projection.
+        w = w.reshape(n_components, n_features)
+        z = x.dot(w.transpose)
+        # predict values.
+        kernel_mat = Numo::NMath.exp(-::Rumale::PairwiseMetric.squared_error(z))
+        kernel_mat[kernel_mat.diag_indices] = 0.0
+        norm = kernel_mat.sum(axis: 1)
+        norm[norm.eq(0)] = 1
+        y_pred = kernel_mat.dot(y) / norm
+        # calculate loss.
+        y_diff = y_pred - y
+        loss = (y_diff**2).sum
+        # calculate gradient.
+        weight_mat = y_diff * y_diff.expand_dims(1) * kernel_mat
+        weight_mat = weight_mat.sum(axis: 0).diag - weight_mat
+        gradient = 8 * z.transpose.dot(weight_mat).dot(x)
+        [loss, gradient.flatten.dup]
+      end
+    end
+  end
+end

data/lib/rumale/metric_learning/neighbourhood_component_analysis.rb

@@ -0,0 +1,167 @@
+# frozen_string_literal: true
+
+require 'lbfgsb'
+
+require 'rumale/base/estimator'
+require 'rumale/base/transformer'
+require 'rumale/utils'
+require 'rumale/validation'
+require 'rumale/pairwise_metric'
+
+module Rumale
+  module MetricLearning
+    # NeighbourhoodComponentAnalysis is a class that implements Neighbourhood Component Analysis.
+    #
+    # @example
+    #   require 'rumale/metric_learning/neighbourhood_component_analysis'
+    #
+    #   transformer = Rumale::MetricLearning::NeighbourhoodComponentAnalysis.new
+    #   transformer.fit(training_samples, traininig_labels)
+    #   low_samples = transformer.transform(testing_samples)
+    #
+    # *Reference*
+    # - Goldberger, J., Roweis, S., Hinton, G., and Salakhutdinov, R., "Neighbourhood Component Analysis," Advances in NIPS'17, pp. 513--520, 2005.
+    class NeighbourhoodComponentAnalysis < ::Rumale::Base::Estimator
+      include ::Rumale::Base::Transformer
+
+      # Returns the neighbourhood components.
+      # @return [Numo::DFloat] (shape: [n_components, n_features])
+      attr_reader :components
+
+      # Return the number of iterations run for optimization
+      # @return [Integer]
+      attr_reader :n_iter
+
+      # Return the random generator.
+      # @return [Random]
+      attr_reader :rng
+
+      # Create a new transformer with NeighbourhoodComponentAnalysis.
+      #
+      # @param n_components [Integer] The number of components.
+      # @param init [String] The initialization method for components ('random' or 'pca').
+      # @param max_iter [Integer] The maximum number of iterations.
+      # @param tol [Float] The tolerance of termination criterion.
+      #   This value is given as tol / Lbfgsb::DBL_EPSILON to the factr argument of Lbfgsb.minimize method.
+      # @param verbose [Boolean] The flag indicating whether to output loss during iteration.
+      #   If true is given, 'iterate.dat' file is generated by lbfgsb.rb.
+      # @param random_seed [Integer] The seed value using to initialize the random generator.
+      def initialize(n_components: nil, init: 'random', max_iter: 100, tol: 1e-6, verbose: false, random_seed: nil)
+        super()
+        @params = {
+          n_components: n_components,
+          init: init,
+          max_iter: max_iter,
+          tol: tol,
+          verbose: verbose,
+          random_seed: random_seed || srand
+        }
+        @rng = Random.new(@params[:random_seed])
+      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 labels to be used for fitting the model.
+      # @return [NeighbourhoodComponentAnalysis] The learned classifier itself.
+      def fit(x, y)
+        x = ::Rumale::Validation.check_convert_sample_array(x)
+        y = ::Rumale::Validation.check_convert_label_array(y)
+        ::Rumale::Validation.check_sample_size(x, y)
+
+        n_features = x.shape[1]
+        n_components = if @params[:n_components].nil?
+                         n_features
+                       else
+                         [n_features, @params[:n_components]].min
+                       end
+        @components, @n_iter = optimize_components(x, y, n_features, n_components)
+        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 model.
+      # @param y [Numo::Int32] (shape: [n_samples]) The labels to be used for fitting the model.
+      # @return [Numo::DFloat] (shape: [n_samples, n_components]) The transformed data
+      def fit_transform(x, y)
+        x = ::Rumale::Validation.check_convert_sample_array(x)
+        y = ::Rumale::Validation.check_convert_label_array(y)
+        ::Rumale::Validation.check_sample_size(x, y)
+
+        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 model.
+      # @return [Numo::DFloat] (shape: [n_samples, n_components]) The transformed data.
+      def transform(x)
+        x = ::Rumale::Validation.check_convert_sample_array(x)
+
+        x.dot(@components.transpose)
+      end
+
+      private
+
+      def init_components(x, n_features, n_components)
+        if @params[:init] == 'pca'
+          pca = ::Rumale::Decomposition::PCA.new(n_components: n_components)
+          pca.fit(x).components.flatten.dup
+        else
+          ::Rumale::Utils.rand_normal([n_features, n_components], @rng.dup).flatten.dup
+        end
+      end
+
+      def optimize_components(x, y, n_features, n_components)
+        # initialize components.
+        comp_init = init_components(x, n_features, n_components)
+        # initialize optimization results.
+        res = {}
+        res[:x] = comp_init
+        res[:n_iter] = 0
+        # perform optimization.
+        verbose = @params[:verbose] ? 1 : -1
+        res = Lbfgsb.minimize(
+          fnc: method(:nca_fnc), jcb: true, x_init: comp_init, args: [x, y],
+          maxiter: @params[:max_iter], factr: @params[:tol] / Lbfgsb::DBL_EPSILON, verbose: verbose
+        )
+        # return the results.
+        n_iter = res[:n_iter]
+        comps = n_components == 1 ? res[:x].dup : res[:x].reshape(n_components, n_features)
+        [comps, n_iter]
+      end
+
+      def nca_fnc(w, x, y)
+        # initialize some variables.
+        n_samples, n_features = x.shape
+        n_components = w.size / n_features
+        # projection.
+        w = w.reshape(n_components, n_features)
+        z = x.dot(w.transpose)
+        # calculate probability matrix.
+        prob_mat = probability_matrix(z)
+        # calculate loss and gradient.
+        # NOTE:
+        # NCA attempts to maximize its objective function.
+        # For the minization algorithm, the objective function value is subtracted from the maixmum value (n_samples).
+        mask_mat = y.expand_dims(1).eq(y)
+        masked_prob_mat = prob_mat * mask_mat
+        loss = n_samples - masked_prob_mat.sum
+        sum_probs = masked_prob_mat.sum(axis: 1)
+        weight_mat = (sum_probs.expand_dims(1) * prob_mat - masked_prob_mat)
+        weight_mat += weight_mat.transpose
+        weight_mat = weight_mat.sum(axis: 0).diag - weight_mat
+        gradient = -2 * z.transpose.dot(weight_mat).dot(x)
+        [loss, gradient.flatten.dup]
+      end
+
+      def probability_matrix(z)
+        prob_mat = Numo::NMath.exp(-::Rumale::PairwiseMetric.squared_error(z))
+        prob_mat[prob_mat.diag_indices] = 0.0
+        prob_mat /= prob_mat.sum(axis: 1).expand_dims(1)
+        prob_mat
+      end
+    end
+  end
+end

data/lib/rumale/metric_learning/version.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+# Rumale is a machine learning library in Ruby.
+module Rumale
+  # Module for metric learning algorithms.
+  module MetricLearning
+    # @!visibility private
+    VERSION = '0.24.0'
+  end
+end

data/lib/rumale/metric_learning.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+require 'numo/narray'
+
+require_relative 'metric_learning/fisher_discriminant_analysis'
+require_relative 'metric_learning/mlkr'
+require_relative 'metric_learning/neighbourhood_component_analysis'
+require_relative 'metric_learning/version'

metadata

@@ -0,0 +1,114 @@
+--- !ruby/object:Gem::Specification
+name: rumale-metric_learning
+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: lbfgsb
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.3.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.3.0
+- !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
+- !ruby/object:Gem::Dependency
+  name: rumale-decomposition
+  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::MetricLearning provides metric learning algorithms,
+  such as Fisher Discriminant Analysis and Neighboourhood Component Analysis
+  with Rumale interface.
+email:
+- yoshoku@outlook.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE.txt
+- README.md
+- lib/rumale/metric_learning.rb
+- lib/rumale/metric_learning/fisher_discriminant_analysis.rb
+- lib/rumale/metric_learning/mlkr.rb
+- lib/rumale/metric_learning/neighbourhood_component_analysis.rb
+- lib/rumale/metric_learning/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-metric_learning
+  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::MetricLearning provides metric learning algorithms with Rumale interface.
+test_files: []