rumale-neural_network 0.24.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 48d32f0d24a38ae0fe2976d323a949c621305348e0629f3b4b99b142da8e311d
+  data.tar.gz: 8b41c40aa425001c9ee8244e0da8f4de113177fbf41c3d5a9bad2633c778ff84
+SHA512:
+  metadata.gz: 5661b39220d75b8fbb60ce73b499a592a66a939c106d7643171fccf1ee5b5e018d139bdae2b89ec70e9987b8869aa48cf8681b90a01cd62fa4399a44f87682bd
+  data.tar.gz: 50094943ebe950cf8ea9056e545167159ac93a81378253e2e33b794db98f82c66b4fe46541631803d2f7469993212528b5b6f22e089b92ffb32a701f1ea0a674

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

@@ -0,0 +1,293 @@
+# frozen_string_literal: true
+
+require 'rumale/base/estimator'
+require 'rumale/utils'
+
+module Rumale
+  module NeuralNetwork
+    # @!visibility private
+    # This module consists of the classes that implement layer functions of neural network.
+    module Layer
+      # @!visibility private
+      # Affine is a class that calculates the linear transform.
+      # This class is used internally.
+      class Affine
+        # @!visibility private
+        def initialize(n_inputs: nil, n_outputs: nil, optimizer: nil, rng: nil)
+          @weight = 0.01 * ::Rumale::Utils.rand_normal([n_inputs, n_outputs], rng)
+          @bias = Numo::DFloat.zeros(n_outputs)
+          @optimizer_weight = optimizer.dup
+          @optimizer_bias = optimizer.dup
+        end
+
+        # @!visibility private
+        def forward(x)
+          out = x.dot(@weight) + @bias
+
+          backward = proc do |dout|
+            dx = dout.dot(@weight.transpose)
+            dw = x.transpose.dot(dout)
+            db = dout.sum(axis: 0)
+
+            @weight = @optimizer_weight.call(@weight, dw)
+            @bias = @optimizer_bias.call(@bias, db)
+
+            dx
+          end
+
+          [out, backward]
+        end
+      end
+
+      # @!visibility private
+      # Dropout is a class that performs dropout regularization.
+      # This class is used internally.
+      class Dropout
+        # @!visibility private
+        def initialize(rate: 0.3, rng: nil)
+          @rate = rate
+          @rng = rng
+        end
+
+        # @!visibility private
+        def forward(x)
+          rand_mat = ::Rumale::Utils.rand_uniform(x.shape, @rng)
+          mask = rand_mat.ge(@rate)
+          out = x * mask
+          out *= 1.fdiv(1 - @rate) if @rate < 1.0
+
+          backward = proc { |dout| dout * mask }
+
+          [out, backward]
+        end
+      end
+
+      # @!visibility private
+      # ReLU is a class that calculates rectified linear function.
+      # This class is used internally.
+      class Relu
+        # @!visibility private
+        def forward(x)
+          mask = x.gt(0)
+          out = x * mask
+
+          backward = proc { |dout| dout * mask }
+
+          [out, backward]
+        end
+      end
+    end
+
+    # @!visibility private
+    # This module consists of the classes that implement loss function for neural network.
+    module Loss
+      # @!visibility private
+      # MeanSquaredError is a class that calculates mean squared error for regression task.
+      # This class is used internally.
+      class MeanSquaredError
+        # @!visibility private
+        def call(out, y)
+          sz_batch = y.shape[0]
+          diff = out - y
+          loss = (diff**2).sum.fdiv(sz_batch)
+          dout = 2.fdiv(sz_batch) * diff
+          [loss, dout]
+        end
+      end
+
+      # @!visibility private
+      # SoftmaxCrossEntropy is a class that calculates softmax cross-entropy for classification task.
+      # This class is used internally.
+      class SoftmaxCrossEntropy
+        # @!visibility private
+        def call(out, y)
+          sz_batch = y.shape[0]
+          z = softmax(out)
+          loss = -(y * Numo::NMath.log(z + 1e-8)).sum.fdiv(sz_batch)
+          dout = (z - y) / sz_batch
+          [loss, dout]
+        end
+
+        private
+
+        def softmax(x)
+          clip = x.max(-1).expand_dims(-1)
+          exp_x = Numo::NMath.exp(x - clip)
+          exp_x / exp_x.sum(axis: -1).expand_dims(-1)
+        end
+      end
+    end
+
+    # @!visibility private
+    # This module consists of the classes for implementing neural network model.
+    module Model
+      # @!visibility private
+      attr_reader :layers
+
+      # @!visibility private
+      # Sequential is a class that implements linear stack model.
+      # This class is used internally.
+      class Sequential
+        # @!visibility private
+        def initialize
+          @layers = []
+        end
+
+        # @!visibility private
+        def push(ops)
+          @layers.push(ops)
+          self
+        end
+
+        # @!visibility private
+        def delete_dropout
+          @layers.delete_if { |node| node.is_a?(Layer::Dropout) }
+          self
+        end
+
+        # @!visibility private
+        def forward(x)
+          backprops = []
+          out = x.dup
+
+          @layers.each do |l|
+            out, bw = l.forward(out)
+            backprops.push(bw)
+          end
+
+          backward = proc do |dout|
+            backprops.reverse_each { |bw| dout = bw.call(dout) }
+            dout
+          end
+
+          [out, backward]
+        end
+      end
+    end
+
+    # @!visibility private
+    # This module consists of the classes that implement optimizers adaptively tuning learning rate.
+    module Optimizer
+      # @!visibility private
+      # Adam is a class that implements Adam optimizer.
+      #
+      # *Reference*
+      # - Kingma, D P., and Ba, J., "Adam: A Method for Stochastic Optimization," Proc. ICLR'15, 2015.
+      class Adam
+        # @!visibility private
+        # Create a new optimizer with Adam
+        #
+        # @param learning_rate [Float] The initial value of learning rate.
+        # @param decay1 [Float] The smoothing parameter for the first moment.
+        # @param decay2 [Float] The smoothing parameter for the second moment.
+        def initialize(learning_rate: 0.001, decay1: 0.9, decay2: 0.999)
+          @params = {
+            learning_rate: learning_rate,
+            decay1: decay1,
+            decay2: decay2
+          }
+          @iter = 0
+        end
+
+        # @!visibility private
+        # Calculate the updated weight with Adam adaptive learning rate.
+        #
+        # @param weight [Numo::DFloat] (shape: [n_features]) The weight to be updated.
+        # @param gradient [Numo::DFloat] (shape: [n_features]) The gradient for updating the weight.
+        # @return [Numo::DFloat] (shape: [n_feautres]) The updated weight.
+        def call(weight, gradient)
+          @fst_moment ||= Numo::DFloat.zeros(weight.shape)
+          @sec_moment ||= Numo::DFloat.zeros(weight.shape)
+
+          @iter += 1
+
+          @fst_moment = @params[:decay1] * @fst_moment + (1.0 - @params[:decay1]) * gradient
+          @sec_moment = @params[:decay2] * @sec_moment + (1.0 - @params[:decay2]) * gradient**2
+          nm_fst_moment = @fst_moment / (1.0 - @params[:decay1]**@iter)
+          nm_sec_moment = @sec_moment / (1.0 - @params[:decay2]**@iter)
+
+          weight - @params[:learning_rate] * nm_fst_moment / (nm_sec_moment**0.5 + 1e-8)
+        end
+      end
+    end
+
+    # BaseMLP is an abstract class for implementation of multi-layer peceptron estimator.
+    # This class is used internally.
+    class BaseMLP < ::Rumale::Base::Estimator
+      # Create a multi-layer perceptron estimator.
+      #
+      # @param hidden_units [Array] The number of units in the i-th hidden layer.
+      # @param dropout_rate [Float] The rate of the units to drop.
+      # @param learning_rate [Float] The initial value of learning rate in Adam optimizer.
+      # @param decay1 [Float] The smoothing parameter for the first moment in Adam optimizer.
+      # @param decay2 [Float] The smoothing parameter for the second moment in Adam optimizer.
+      # @param max_iter [Integer] The maximum number of epochs that indicates
+      #   how many times the whole data is given to the training process.
+      # @param batch_size [Intger] The size of the mini batches.
+      # @param tol [Float] The tolerance of loss for terminating optimization.
+      # @param verbose [Boolean] The flag indicating whether to output loss during iteration.
+      # @param random_seed [Integer] The seed value using to initialize the random generator.
+      def initialize(hidden_units: [128, 128], dropout_rate: 0.4, learning_rate: 0.001, decay1: 0.9, decay2: 0.999,
+                     max_iter: 200, batch_size: 50, tol: 1e-4, verbose: false, random_seed: nil)
+        super()
+        @params = {
+          hidden_units: hidden_units,
+          dropout_rate: dropout_rate,
+          learning_rate: learning_rate,
+          decay1: decay1,
+          decay2: decay2,
+          max_iter: max_iter,
+          batch_size: batch_size,
+          tol: tol,
+          verbose: verbose,
+          random_seed: random_seed || srand
+        }
+        @rng = Random.new(@params[:random_seed])
+      end
+
+      private
+
+      def buld_network(n_inputs, n_outputs, srng = nil)
+        adam = ::Rumale::NeuralNetwork::Optimizer::Adam.new(
+          learning_rate: @params[:learning_rate], decay1: @params[:decay1], decay2: @params[:decay2]
+        )
+        model = ::Rumale::NeuralNetwork::Model::Sequential.new
+        n_units = [n_inputs, *@params[:hidden_units]]
+        n_units.each_cons(2) do |n_in, n_out|
+          model.push(::Rumale::NeuralNetwork::Layer::Affine.new(n_inputs: n_in, n_outputs: n_out, optimizer: adam, rng: srng))
+          model.push(::Rumale::NeuralNetwork::Layer::Relu.new)
+          model.push(::Rumale::NeuralNetwork::Layer::Dropout.new(rate: @params[:dropout_rate], rng: srng))
+        end
+        model.push(::Rumale::NeuralNetwork::Layer::Affine.new(n_inputs: n_units[-1], n_outputs: n_outputs, optimizer: adam,
+                                                              rng: srng))
+      end
+
+      def train(x, y, network, loss_func, srng = nil)
+        class_name = self.class.to_s.split('::').last
+        n_samples = x.shape[0]
+
+        @params[:max_iter].times do |t|
+          sample_ids = Array(0...n_samples)
+          sample_ids.shuffle!(random: srng)
+          until (subset_ids = sample_ids.shift(@params[:batch_size])).empty?
+            # random sampling
+            sub_x = x[subset_ids, true].dup
+            sub_y = y[subset_ids, true].dup
+            # forward
+            out, backward = network.forward(sub_x)
+            # calc loss function
+            loss, dout = loss_func.call(out, sub_y)
+            break if loss < @params[:tol]
+
+            # backward
+            backward.call(dout)
+          end
+          @n_iter = t + 1
+          puts "[#{class_name}] Loss after #{@n_iter} epochs: #{loss}" if @params[:verbose]
+        end
+
+        network
+      end
+    end
+  end
+end

data/lib/rumale/neural_network/mlp_classifier.rb

@@ -0,0 +1,117 @@
+# frozen_string_literal: true
+
+require 'rumale/base/classifier'
+require 'rumale/utils'
+require 'rumale/validation'
+require 'rumale/neural_network/base_mlp'
+
+module Rumale
+  module NeuralNetwork
+    # MLPClassifier is a class that implements classifier based on multi-layer perceptron.
+    # MLPClassifier use ReLu as the activation function and Adam as the optimization method
+    # and softmax cross entropy as the loss function.
+    #
+    # @example
+    #   require 'rumale/neural_network/mlp_classifier'
+    #
+    #   estimator = Rumale::NeuralNetwork::MLPClassifier.new(hidden_units: [100, 100], dropout_rate: 0.3)
+    #   estimator.fit(training_samples, traininig_labels)
+    #   results = estimator.predict(testing_samples)
+    class MLPClassifier < BaseMLP
+      include ::Rumale::Base::Classifier
+
+      # Return the network.
+      # @return [Rumale::NeuralNetwork::Model::Sequential]
+      attr_reader :network
+
+      # Return the class labels.
+      # @return [Numo::Int32] (size: n_classes)
+      attr_reader :classes
+
+      # 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 classifier with multi-layer preceptron.
+      #
+      # @param hidden_units [Array] The number of units in the i-th hidden layer.
+      # @param dropout_rate [Float] The rate of the units to drop.
+      # @param learning_rate [Float] The initial value of learning rate in Adam optimizer.
+      # @param decay1 [Float] The smoothing parameter for the first moment in Adam optimizer.
+      # @param decay2 [Float] The smoothing parameter for the second moment in Adam optimizer.
+      # @param max_iter [Integer] The maximum number of epochs that indicates
+      #   how many times the whole data is given to the training process.
+      # @param batch_size [Intger] The size of the mini batches.
+      # @param tol [Float] The tolerance of loss for terminating optimization.
+      # @param verbose [Boolean] The flag indicating whether to output loss during iteration.
+      # @param random_seed [Integer] The seed value using to initialize the random generator.
+      def initialize(hidden_units: [128, 128], dropout_rate: 0.4, learning_rate: 0.001, decay1: 0.9, decay2: 0.999,
+                     max_iter: 200, batch_size: 50, tol: 1e-4, verbose: false, random_seed: nil)
+        super
+      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 [MLPClassifier] 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)
+
+        @classes = Numo::Int32[*y.to_a.uniq.sort]
+        n_labels = @classes.size
+        n_features = x.shape[1]
+        sub_rng = @rng.dup
+
+        loss = ::Rumale::NeuralNetwork::Loss::SoftmaxCrossEntropy.new
+        @network = buld_network(n_features, n_labels, sub_rng)
+        @network = train(x, one_hot_encode(y), @network, loss, sub_rng)
+        @network.delete_dropout
+
+        self
+      end
+
+      # Predict class labels for samples.
+      #
+      # @param x [Numo::DFloat] (shape: [n_samples, n_features]) The samples to predict the labels.
+      # @return [Numo::Int32] (shape: [n_samples]) Predicted class label per sample.
+      def predict(x)
+        x = ::Rumale::Validation.check_convert_sample_array(x)
+
+        n_samples = x.shape[0]
+        decision_values = predict_proba(x)
+        predicted = Array.new(n_samples) { |n| @classes[decision_values[n, true].max_index] }
+        Numo::Int32.asarray(predicted)
+      end
+
+      # Predict probability for samples.
+      #
+      # @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)
+        x = ::Rumale::Validation.check_convert_sample_array(x)
+
+        out, = @network.forward(x)
+        softmax(out)
+      end
+
+      private
+
+      def one_hot_encode(y)
+        ::Rumale::Utils.binarize_labels(y)
+      end
+
+      def softmax(x)
+        clip = x.max(-1).expand_dims(-1)
+        exp_x = Numo::NMath.exp(x - clip)
+        exp_x / exp_x.sum(axis: -1).expand_dims(-1)
+      end
+    end
+  end
+end

data/lib/rumale/neural_network/mlp_regressor.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+require 'rumale/base/regressor'
+require 'rumale/neural_network/base_mlp'
+require 'rumale/validation'
+
+module Rumale
+  module NeuralNetwork
+    # MLPRegressor is a class that implements regressor based on multi-layer perceptron.
+    # MLPRegressor use ReLu as the activation function and Adam as the optimization method
+    # and mean squared error as the loss function.
+    #
+    # @example
+    #   require 'rumale/neural_network/mlp_regressor'
+    #
+    #   estimator = Rumale::NeuralNetwork::MLPRegressor.new(hidden_units: [100, 100], dropout_rate: 0.3)
+    #   estimator.fit(training_samples, traininig_labels)
+    #   results = estimator.predict(testing_samples)
+    class MLPRegressor < BaseMLP
+      include ::Rumale::Base::Regressor
+
+      # Return the network.
+      # @return [Rumale::NeuralNetwork::Model::Sequential]
+      attr_reader :network
+
+      # 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 regressor with multi-layer perceptron.
+      #
+      # @param hidden_units [Array] The number of units in the i-th hidden layer.
+      # @param dropout_rate [Float] The rate of the units to drop.
+      # @param learning_rate [Float] The initial value of learning rate in Adam optimizer.
+      # @param decay1 [Float] The smoothing parameter for the first moment in Adam optimizer.
+      # @param decay2 [Float] The smoothing parameter for the second moment in Adam optimizer.
+      # @param max_iter [Integer] The maximum number of epochs that indicates
+      #   how many times the whole data is given to the training process.
+      # @param batch_size [Intger] The size of the mini batches.
+      # @param tol [Float] The tolerance of loss for terminating optimization.
+      # @param verbose [Boolean] The flag indicating whether to output loss during iteration.
+      # @param random_seed [Integer] The seed value using to initialize the random generator.
+      def initialize(hidden_units: [128, 128], dropout_rate: 0.4, learning_rate: 0.001, decay1: 0.9, decay2: 0.999,
+                     max_iter: 200, batch_size: 50, tol: 1e-4, verbose: false, random_seed: nil)
+        super
+      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, n_outputs]) The taget values to be used for fitting the model.
+      # @return [MLPRegressor] The learned regressor 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)
+
+        y = y.expand_dims(1) if y.ndim == 1
+        n_targets = y.shape[1]
+        n_features = x.shape[1]
+        sub_rng = @rng.dup
+
+        loss = ::Rumale::NeuralNetwork::Loss::MeanSquaredError.new
+        @network = buld_network(n_features, n_targets, sub_rng)
+        @network = train(x, y, @network, loss, sub_rng)
+        @network.delete_dropout
+
+        self
+      end
+
+      # Predict values for samples.
+      #
+      # @param x [Numo::DFloat] (shape: [n_samples, n_features]) The samples to predict the values.
+      # @return [Numo::DFloat] (shape: [n_samples, n_outputs]) Predicted values per sample.
+      def predict(x)
+        x = ::Rumale::Validation.check_convert_sample_array(x)
+
+        out, = @network.forward(x)
+        out = out[true, 0] if out.shape[1] == 1
+        out
+      end
+    end
+  end
+end

data/lib/rumale/neural_network/version.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+# Rumale is a machine learning library in Ruby.
+module Rumale
+  # This module consists of the modules and classes for implementation multi-layer perceptron estimator.
+  module NeuralNetwork
+    # @!visibility private
+    VERSION = '0.24.0'
+  end
+end

data/lib/rumale/neural_network.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+require 'numo/narray'
+
+require_relative 'neural_network/version'
+
+require_relative 'neural_network/base_mlp'
+require_relative 'neural_network/mlp_classifier'
+require_relative 'neural_network/mlp_regressor'

metadata

@@ -0,0 +1,86 @@
+--- !ruby/object:Gem::Specification
+name: rumale-neural_network
+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::NeuralNetwork provides classifier and regression
+  based on multi-layer perceptron with Rumale interface.
+email:
+- yoshoku@outlook.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE.txt
+- README.md
+- lib/rumale/neural_network.rb
+- lib/rumale/neural_network/base_mlp.rb
+- lib/rumale/neural_network/mlp_classifier.rb
+- lib/rumale/neural_network/mlp_regressor.rb
+- lib/rumale/neural_network/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-neural_network
+  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::NeuralNetwork provides classifier and regression based on multi-layer
+  perceptron with Rumale interface.
+test_files: []