rumale-manifold 0.24.0 → 0.26.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6c0ef66c09b01569728f5b856236aac366cd0048055edb91e26f4d206fe44033
-  data.tar.gz: dc5fc6ad6423e6c9d65adbbee74cb79817b94001a1c8e0753b62f3fbfd5d8ded
+  metadata.gz: a617aca87458b95ebab75cc6913fe8064c2eeb96ab002483bda708f1a40aafe1
+  data.tar.gz: e8e9186bbf583fc504aabd283a3b2f5bdfcff9c79cab7d52fe3b6049c2bd233b
 SHA512:
-  metadata.gz: 4601ea832a9583c8987a457ea7b4c9e4d9d094e041041903d05f554c8a4ec34324ed9d7c34282f9825a68eca67d5bc89e0082489362b93f173f4f944ddc896f5
-  data.tar.gz: 20eaeed3f214929b208e4faa04929270b6a28c0b89b835f0098ce90a8877f912a5a476fa2dcebd2f62a06228a783cd0eda55fa955982cbb70dbcfaf165cf1042
+  metadata.gz: 30d1e6d74f61535d0285e40d98c54b15344128c8144ec9694bc76bb8d26a70f932accf3b77e7c6c4b55c7225e99b3b7ef354dba85684678e47f722a5a60a602b
+  data.tar.gz: b6b56afeec456babec131c9bc253ec31d9324c9b39d40b71e0825df930176cb6c8854df57f26d5cdd546aabada022c6e671abb2236ea52c8200cf9b834f449fc

data/LICENSE.txt

@@ -1,4 +1,4 @@
-Copyright (c) 2022 Atsushi Tatsuma
+Copyright (c) 2022-2023 Atsushi Tatsuma
 All rights reserved.
 
 Redistribution and use in source and binary forms, with or without

data/README.md

@@ -1,7 +1,7 @@
 # Rumale::Manifold
 
 [![Gem Version](https://badge.fury.io/rb/rumale-manifold.svg)](https://badge.fury.io/rb/rumale-manifold)
-[![BSD 3-Clause License](https://img.shields.io/badge/License-BSD%203--Clause-orange.svg)](https://gitlab.com/yoshoku/rumale/-/blob/main/rumale-manifold/LICENSE.txt)
+[![BSD 3-Clause License](https://img.shields.io/badge/License-BSD%203--Clause-orange.svg)](https://github.com/yoshoku/rumale/blob/main/rumale-manifold/LICENSE.txt)
 [![Documentation](https://img.shields.io/badge/api-reference-blue.svg)](https://yoshoku.github.io/rumale/doc/Rumale/Manifold.html)
 
 Rumale is a machine learning library in Ruby.

data/lib/rumale/manifold/laplacian_eigenmaps.rb

@@ -0,0 +1,125 @@
+# frozen_string_literal: true
+
+require 'rumale/base/estimator'
+require 'rumale/base/transformer'
+require 'rumale/pairwise_metric'
+require 'rumale/validation'
+
+module Rumale
+  module Manifold
+    # LaplacianEigenmaps is a class that implements Laplacian Eigenmaps.
+    #
+    # @example
+    #   require 'numo/linalg/autoloader'
+    #   require 'rumale/manifold/laplacian_eigenmaps'
+    #
+    #   lem = Rumale::Manifold::LaplacianEigenmaps.new(n_components: 2, n_neighbors: 15)
+    #   z = lem.fit_transform(x)
+    #
+    # *Reference*
+    # - Belkin, M., and Niyogi, P., "Laplacian Eigenmaps and Spectral Techniques for Embedding and Clustering," Proc. NIPS'01, pp. 585--591, 2001.
+    class LaplacianEigenmaps < Rumale::Base::Estimator
+      include Rumale::Base::Transformer
+
+      # Return the data in representation space.
+      # @return [Numo::DFloat] (shape: [n_samples, n_components])
+      attr_reader :embedding
+
+      # Create a new transformer with Laplacian Eigenmaps.
+      #
+      # @param n_components [Integer] The number of dimensions on representation space.
+      # @param gamma [Nil/Float] The parameter of RBF kernel. If nil is given, the weight of affinity matrix sets to 1.
+      # @param n_neighbors [Integer] The number of nearest neighbors for k-nearest neighbor graph construction.
+      def initialize(n_components: 2, gamma: nil, n_neighbors: 10)
+        super()
+        @params = {
+          n_components: n_components,
+          gamma: gamma,
+          n_neighbors: [1, n_neighbors].max
+        }
+      end
+
+      # Fit the model with given training data.
+      #
+      # @overload fit(x) -> LaplacianEigenmaps
+      #   @param x [Numo::DFloat] (shape: [n_samples, n_features]) The training data to be used for fitting the model.
+      #   @return [LaplacianEigenmaps] The learned transformer itself.
+      def fit(x, _y = nil)
+        raise 'LaplacianEigenmaps#fit requires Numo::Linalg but that is not loaded' unless enable_linalg?(warning: false)
+
+        x = Rumale::Validation.check_convert_sample_array(x)
+
+        distance_mat = Rumale::PairwiseMetric.squared_error(x)
+        neighbor_graph = k_neighbor_graph(distance_mat, @params[:n_neighbors], true)
+        affinity_mat = if @params[:gamma].nil?
+                         neighbor_graph
+                       else
+                         neighbor_graph * Numo::NMath.exp(-@params[:gamma] * distance_mat)
+                       end
+        degree_mat = affinity_mat.sum(axis: 1).diag
+        laplacian_mat = degree_mat - affinity_mat
+
+        _, eig_vecs = Numo::Linalg.eigh(laplacian_mat, degree_mat, vals_range: 1...(1 + @params[:n_components]))
+
+        @embedding = @params[:n_components] == 1 ? eig_vecs[true, 0].dup : eig_vecs.dup
+        @x_train = 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 fitting the model.
+      #   @return [Numo::DFloat] (shape: [n_samples, n_components]) The transformed data
+      def fit_transform(x, _y = nil)
+        unless enable_linalg?(warning: false)
+          raise 'LaplacianEigenmaps#fit_transform requires Numo::Linalg but that is not loaded'
+        end
+
+        fit(x).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)
+
+        distance_mat = Rumale::PairwiseMetric.squared_error(x, @x_train)
+        neighbor_graph = k_neighbor_graph(distance_mat, @params[:n_neighbors], false)
+        affinity_mat = if @params[:gamma].nil?
+                         neighbor_graph
+                       else
+                         neighbor_graph * Numo::NMath.exp(-@params[:gamma] * distance_mat)
+                       end
+        normalizer = Numo::NMath.sqrt(affinity_mat.mean * affinity_mat.mean(axis: 1))
+        n_train_samples = @x_train.shape[0]
+        weight_mat = 1.fdiv(n_train_samples) * (affinity_mat.transpose / normalizer).transpose
+        weight_mat.dot(@embedding)
+      end
+
+      private
+
+      def k_neighbor_graph(distance_mat, n_neighbors, contain_self)
+        n_samples = distance_mat.shape[0]
+        if contain_self
+          neighbor_graph = Numo::DFloat.zeros(n_samples, n_samples)
+          n_samples.times do |n|
+            neighbor_ids = (distance_mat[n, true].sort_index.to_a - [n])[0...n_neighbors]
+            neighbor_graph[n, neighbor_ids] = 1
+          end
+          Numo::DFloat.maximum(neighbor_graph, neighbor_graph.transpose)
+        else
+          neighbor_graph = Numo::DFloat.zeros(distance_mat.shape)
+          n_samples.times do |n|
+            neighbor_ids = distance_mat[n, true].sort_index.to_a[0...n_neighbors]
+            neighbor_graph[n, neighbor_ids] = 1
+          end
+          neighbor_graph
+        end
+      end
+    end
+  end
+end

data/lib/rumale/manifold/locally_linear_embedding.rb

@@ -0,0 +1,128 @@
+# frozen_string_literal: true
+
+require 'rumale/base/estimator'
+require 'rumale/base/transformer'
+require 'rumale/pairwise_metric'
+require 'rumale/validation'
+
+module Rumale
+  module Manifold
+    # LocallyLinearEmbedding is a class that implements Loccaly Linear Embedding.
+    #
+    # @example
+    #   require 'numo/linalg/autoloader'
+    #   require 'rumale/manifold/locally_linear_embedding'
+    #
+    #   lem = Rumale::Manifold::LocallyLinearEmbedding.new(n_components: 2, n_neighbors: 15)
+    #   z = lem.fit_transform(x)
+    #
+    # *Reference*
+    # - Roweis, S., and Saul, L., "Nonlinear Dimensionality Reduction by Locally Linear Embedding," J. of Science, vol. 290, pp. 2323-2326, 2000.
+    class LocallyLinearEmbedding < Rumale::Base::Estimator
+      include Rumale::Base::Transformer
+
+      # Return the data in representation space.
+      # @return [Numo::DFloat] (shape: [n_samples, n_components])
+      attr_reader :embedding
+
+      # Create a new transformer with Locally Linear Embedding.
+      #
+      # @param n_components [Integer] The number of dimensions on representation space.
+      # @param n_neighbors [Integer] The number of nearest neighbors for k-nearest neighbor graph construction.
+      # @param reg_param [Float] The reguralization parameter for local gram matrix.
+      def initialize(n_components: 2, n_neighbors: 10, reg_param: 1e-3)
+        super()
+        @params = {
+          n_components: n_components,
+          n_neighbors: [1, n_neighbors].max,
+          reg_param: reg_param
+        }
+      end
+
+      # Fit the model with given training data.
+      #
+      # @overload fit(x) -> LocallyLinearEmbedding
+      #   @param x [Numo::DFloat] (shape: [n_samples, n_features]) The training data to be used for fitting the model.
+      #   @return [LocallyLinearEmbedding] The learned transformer itself.
+      def fit(x, _y = nil)
+        raise 'LocallyLinearEmbedding#fit requires Numo::Linalg but that is not loaded' unless enable_linalg?(warning: false)
+
+        x = Rumale::Validation.check_convert_sample_array(x)
+
+        n_samples = x.shape[0]
+        tol = @params[:reg_param].fdiv(@params[:n_neighbors])
+        distance_mat = Rumale::PairwiseMetric.squared_error(x)
+        neighbor_ids = neighbor_ids(distance_mat, @params[:n_neighbors], true)
+
+        affinity_mat = Numo::DFloat.eye(n_samples)
+        n_samples.times do |n|
+          x_local = x[neighbor_ids[n, true], true] - x[n, true]
+          gram_mat = x_local.dot(x_local.transpose)
+          gram_mat += tol * gram_mat.trace * Numo::DFloat.eye(@params[:n_neighbors])
+          weights = Numo::Linalg.solve(gram_mat, Numo::DFloat.ones(@params[:n_neighbors]))
+          weights /= weights.sum + 1e-8
+          affinity_mat[n, neighbor_ids[n, true]] -= weights
+        end
+
+        kernel_mat = affinity_mat.transpose.dot(affinity_mat)
+        _, eig_vecs = Numo::Linalg.eigh(kernel_mat, vals_range: 1...(1 + @params[:n_components]))
+
+        @embedding = @params[:n_components] == 1 ? eig_vecs[true, 0].dup : eig_vecs.dup
+        @x_train = 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 fitting the model.
+      #   @return [Numo::DFloat] (shape: [n_samples, n_components]) The transformed data
+      def fit_transform(x, _y = nil)
+        unless enable_linalg?(warning: false)
+          raise 'LocallyLinearEmbedding#fit_transform requires Numo::Linalg but that is not loaded'
+        end
+
+        fit(x).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)
+
+        n_samples = x.shape[0]
+        tol = @params[:reg_param].fdiv(@params[:n_neighbors])
+        distance_mat = Rumale::PairwiseMetric.squared_error(x, @x_train)
+        neighbor_ids = neighbor_ids(distance_mat, @params[:n_neighbors], false)
+        weight_mat = Numo::DFloat.zeros(n_samples, @x_train.shape[0])
+
+        n_samples.times do |n|
+          x_local = @x_train[neighbor_ids[n, true], true] - x[n, true]
+          gram_mat = x_local.dot(x_local.transpose)
+          gram_mat += tol * weight_mat.trace * Numo::DFloat.eye(@params[:n_neighbors])
+          weights = Numo::Linalg.solve(gram_mat, Numo::DFloat.ones(@params[:n_neighbors]))
+          weights /= weights.sum + 1e-8
+          weight_mat[n, neighbor_ids[n, true]] = weights
+        end
+
+        weight_mat.dot(@embedding)
+      end
+
+      private
+
+      def neighbor_ids(distance_mat, n_neighbors, contain_self)
+        n_samples = distance_mat.shape[0]
+        neighbor_ids = Numo::Int32.zeros(n_samples, n_neighbors)
+        if contain_self
+          n_samples.times { |n| neighbor_ids[n, true] = (distance_mat[n, true].sort_index.to_a - [n])[0...n_neighbors] }
+        else
+          n_samples.times { |n| neighbor_ids[n, true] = distance_mat[n, true].sort_index.to_a[0...n_neighbors] }
+        end
+        neighbor_ids
+      end
+    end
+  end
+end

data/lib/rumale/manifold/version.rb

@@ -5,6 +5,6 @@ module Rumale
   # Module for data embedding algorithms.
   module Manifold
     # @!visibility private
-    VERSION = '0.24.0'
+    VERSION = '0.26.0'
   end
 end

data/lib/rumale/manifold.rb

@@ -2,6 +2,8 @@
 
 require 'numo/narray'
 
+require_relative 'manifold/laplacian_eigenmaps'
+require_relative 'manifold/locally_linear_embedding'
 require_relative 'manifold/mds'
 require_relative 'manifold/tsne'
 require_relative 'manifold/version'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rumale-manifold
 version: !ruby/object:Gem::Version
-  version: 0.24.0
+  version: 0.26.0
 platform: ruby
 authors:
 - yoshoku
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2022-12-31 00:00:00.000000000 Z
+date: 2023-02-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: numo-narray
@@ -30,28 +30,28 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.24.0
+        version: 0.26.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.24.0
+        version: 0.26.0
 - !ruby/object:Gem::Dependency
   name: rumale-decomposition
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.24.0
+        version: 0.26.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.24.0
+        version: 0.26.0
 description: |
   Rumale::Manifold provides data embedding algorithms,
   such as Multi-dimensional Scaling and t-distributed Stochastic Neighbor Embedding,
@@ -65,16 +65,18 @@ files:
 - LICENSE.txt
 - README.md
 - lib/rumale/manifold.rb
+- lib/rumale/manifold/laplacian_eigenmaps.rb
+- lib/rumale/manifold/locally_linear_embedding.rb
 - lib/rumale/manifold/mds.rb
 - lib/rumale/manifold/tsne.rb
 - lib/rumale/manifold/version.rb
-homepage: https://gitlab.com/yoshoku/rumale
+homepage: https://github.com/yoshoku/rumale
 licenses:
 - BSD-3-Clause
 metadata:
-  homepage_uri: https://gitlab.com/yoshoku/rumale
-  source_code_uri: https://gitlab.com/yoshoku/rumale/-/tree/main/rumale-manifold
-  changelog_uri: https://gitlab.com/yoshoku/rumale/-/blob/main/CHANGELOG.md
+  homepage_uri: https://github.com/yoshoku/rumale
+  source_code_uri: https://github.com/yoshoku/rumale/-/tree/main/rumale-manifold
+  changelog_uri: https://github.com/yoshoku/rumale/-/blob/main/CHANGELOG.md
   rubygems_mfa_required: 'true'
 post_install_message:
 rdoc_options: []