rumale-neural_network 0.27.0 → 0.28.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0641da98a87f6a92f745439fcbbfa1841f66fa1595bd39a110e8981c588be13d
-  data.tar.gz: 2f16621ca494063cb5fca89e03ebe98f16406d04fcbaa86d694c97dccbaf0236
+  metadata.gz: 8c6090291a88fdf2e017af6b56297a109ea668e19432fbb69b9c734aac643269
+  data.tar.gz: 8b88eb8612d9537d298db76bde03e12cfc05251235b70abbf05f302c7e043261
 SHA512:
-  metadata.gz: 51a166a654fe1bf7394947753f9e845516bb3298c98edac96c075155030beebeca2d418ecfa9b5328ff9da5ec247b9bd11118b686b5a7f0ec3b61c8db5544bcc
-  data.tar.gz: 94781cf4f7e721aeba324e07f2ad5975513f2a02fd9c12b7f561cab75dfdb57bd84d87b08380b7cb6fabf8ea8fee85375dadac57f5e0d45bfe9bfb074c17082a
+  metadata.gz: 4c2d5585cb3b6bac2430c0070d28f30a2d7a5573a7e32e7761dfcfc01dd3b40e6664c325f596c53fc5f01ee7e2d882846d3522984d791f878148a67b9ef92c29
+  data.tar.gz: 6bb8ee5bc957255298794a0463a84373ee19e5a663a0fd28c2b7f0ef6e7c91b028a906e2ca88c52fb2996960806839f552e0194292974c76214a35c3b1962d1a

data/lib/rumale/neural_network/base_rbf.rb

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+require 'rumale/base/estimator'
+require 'rumale/pairwise_metric'
+
+module Rumale
+  module NeuralNetwork
+    # BaseRBF is an abstract class for implementation of radial basis function (RBF) network estimator.
+    # This class is used internally.
+    #
+    # *Reference*
+    # - Bugmann, G., "Normalized Gaussian Radial Basis Function networks," Neural Computation, vol. 20, pp. 97--110, 1998.
+    # - Que, Q., and Belkin, M., "Back to the Future: Radial Basis Function Networks Revisited," Proc. of AISTATS'16, pp. 1375--1383, 2016.
+    class BaseRBF < ::Rumale::Base::Estimator
+      # Create a radial basis function network estimator.
+      #
+      # @param hidden_units [Array] The number of units in the hidden layer.
+      # @param gamma [Float] The parameter for the radial basis function, if nil it is 1 / n_features.
+      # @param reg_param [Float] The regularization parameter.
+      # @param normalize [Boolean] The flag indicating whether to normalize the hidden layer output or not.
+      # @param max_iter [Integer] The maximum number of iterations for finding centers.
+      # @param tol [Float] The tolerance of termination criterion for finding centers.
+      # @param random_seed [Integer] The seed value using to initialize the random generator.
+      def initialize(hidden_units: 128, gamma: nil, reg_param: 100.0, normalize: false,
+                     max_iter: 50, tol: 1e-4, random_seed: nil)
+        super()
+        @params = {
+          hidden_units: hidden_units,
+          gamma: gamma,
+          reg_param: reg_param,
+          normalize: normalize,
+          max_iter: max_iter,
+          tol: tol,
+          random_seed: random_seed || srand
+        }
+        @rng = Random.new(@params[:random_seed])
+      end
+
+      private
+
+      def partial_fit(x, y)
+        find_centers(x)
+
+        h = hidden_output(x)
+
+        n_samples = h.shape[0]
+        n_features = h.shape[1]
+        reg_term = 1.fdiv(@params[:reg_param])
+
+        @weight_vec = if n_features <= n_samples
+                        Numo::Linalg.inv(h.transpose.dot(h) + reg_term * Numo::DFloat.eye(n_features)).dot(h.transpose).dot(y)
+                      else
+                        h.transpose.dot(Numo::Linalg.inv(h.dot(h.transpose) + reg_term * Numo::DFloat.eye(n_samples))).dot(y)
+                      end
+      end
+
+      def hidden_output(x)
+        h = ::Rumale::PairwiseMetric.rbf_kernel(x, @centers, @params[:gamma])
+        h /= h.sum(axis: 1).expand_dims(1) if @params[:normalize]
+        h
+      end
+
+      def find_centers(x)
+        # initialize centers randomly
+        n_samples = x.shape[0]
+        sub_rng = @rng.dup
+        rand_id = Array.new(n_centers) { |_v| sub_rng.rand(0...n_samples) }
+        @centers = x[rand_id, true].dup
+
+        # find centers
+        @params[:max_iter].times do |_t|
+          center_ids = assign_centers(x)
+          old_centers = @centers.dup
+          n_centers.times do |n|
+            assigned_bits = center_ids.eq(n)
+            @centers[n, true] = x[assigned_bits.where, true].mean(axis: 0) if assigned_bits.count.positive?
+          end
+          error = Numo::NMath.sqrt(((old_centers - @centers)**2).sum(axis: 1)).mean
+          break if error <= @params[:tol]
+        end
+      end
+
+      def assign_centers(x)
+        distance_matrix = ::Rumale::PairwiseMetric.euclidean_distance(x, @centers)
+        distance_matrix.min_index(axis: 1) - Numo::Int32[*0.step(distance_matrix.size - 1, @centers.shape[0])]
+      end
+
+      def n_centers
+        @params[:hidden_units]
+      end
+    end
+  end
+end

data/lib/rumale/neural_network/base_rvfl.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+require 'rumale/base/estimator'
+require 'rumale/utils'
+
+module Rumale
+  module NeuralNetwork
+    # BaseRVFL is an abstract class for implementation of random vector functional link (RVFL) network.
+    # This class is used internally.
+    #
+    # *Reference*
+    # - Malik, A. K., Gao, R., Ganaie, M. A., Tanveer, M., and Suganthan, P. N., "Random vector functional link network: recent developments, applications, and future directions," Applied Soft Computing, vol. 143, 2023.
+    # - Zhang, L., and Suganthan, P. N., "A comprehensive evaluation of random vector functional link networks," Information Sciences, vol. 367--368, pp. 1094--1105, 2016.
+    class BaseRVFL < ::Rumale::Base::Estimator
+      # Create a random vector functional link network estimator.
+      #
+      # @param hidden_units [Array] The number of units in the hidden layer.
+      # @param reg_param [Float] The regularization parameter.
+      # @param scale [Float] The scale parameter for random weight and bias.
+      # @param random_seed [Integer] The seed value using to initialize the random generator.
+      def initialize(hidden_units: 128, reg_param: 100.0, scale: 1.0, random_seed: nil)
+        super()
+        @params = {
+          hidden_units: hidden_units,
+          reg_param: reg_param,
+          scale: scale,
+          random_seed: random_seed || srand
+        }
+        @rng = Random.new(@params[:random_seed])
+      end
+
+      private
+
+      def partial_fit(x, y)
+        h = hidden_output(x)
+
+        n_samples = h.shape[0]
+        n_features = h.shape[1]
+        reg_term = 1.fdiv(@params[:reg_param])
+
+        @weight_vec = if n_features <= n_samples
+                        Numo::Linalg.inv(h.transpose.dot(h) + reg_term * Numo::DFloat.eye(n_features)).dot(h.transpose).dot(y)
+                      else
+                        h.transpose.dot(Numo::Linalg.inv(h.dot(h.transpose) + reg_term * Numo::DFloat.eye(n_samples))).dot(y)
+                      end
+      end
+
+      def hidden_output(x)
+        sub_rng = @rng.dup
+        n_features = x.shape[1]
+        @random_weight_vec = (2.0 * Rumale::Utils.rand_uniform([n_features, @params[:hidden_units]], sub_rng) - 1.0) * @params[:scale] # rubocop:disbale Layout/LineLength
+        @random_bias = Rumale::Utils.rand_uniform(@params[:hidden_units], sub_rng) * @params[:scale]
+        h = 0.5 * (Numo::NMath.tanh(0.5 * (x.dot(@random_weight_vec) + @random_bias)) + 1.0)
+        Numo::DFloat.hstack([x, h])
+      end
+    end
+  end
+end

data/lib/rumale/neural_network/mlp_regressor.rb

@@ -14,7 +14,7 @@ module Rumale
     #   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)
+    #   estimator.fit(training_samples, traininig_values)
     #   results = estimator.predict(testing_samples)
     class MLPRegressor < BaseMLP
       include ::Rumale::Base::Regressor

data/lib/rumale/neural_network/rbf_classifier.rb

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+require 'rumale/base/classifier'
+require 'rumale/utils'
+require 'rumale/validation'
+require 'rumale/neural_network/base_rbf'
+
+module Rumale
+  module NeuralNetwork
+    # RBFClassifier is a class that implements classifier based on (k-means) radial basis function (RBF) networks.
+    #
+    # @example
+    #   require 'numo/tiny_linalg'
+    #   Numo::Linalg = Numo::TinyLinalg
+    #
+    #   require 'rumale/neural_network/rbf_classifier'
+    #
+    #   estimator = Rumale::NeuralNetwork::RBFClassifier.new(hidden_units: 128, reg_param: 100.0)
+    #   estimator.fit(training_samples, traininig_labels)
+    #   results = estimator.predict(testing_samples)
+    #
+    # *Reference*
+    # - Bugmann, G., "Normalized Gaussian Radial Basis Function networks," Neural Computation, vol. 20, pp. 97--110, 1998.
+    # - Que, Q., and Belkin, M., "Back to the Future: Radial Basis Function Networks Revisited," Proc. of AISTATS'16, pp. 1375--1383, 2016.
+    class RBFClassifier < BaseRBF
+      include ::Rumale::Base::Classifier
+
+      # Return the class labels.
+      # @return [Numo::Int32] (size: n_classes)
+      attr_reader :classes
+
+      # Return the centers in the hidden layer of RBF network.
+      # @return [Numo::DFloat] (shape: [n_centers, n_features])
+      attr_reader :centers
+
+      # Return the weight vector.
+      # @return [Numo::DFloat] (shape: [n_centers, n_classes])
+      attr_reader :weight_vec
+
+      # Return the random generator.
+      # @return [Random]
+      attr_reader :rng
+
+      # Create a new classifier with (k-means) RBF networks.
+      #
+      # @param hidden_units [Array] The number of units in the hidden layer.
+      # @param gamma [Float] The parameter for the radial basis function, if nil it is 1 / n_features.
+      # @param reg_param [Float] The regularization parameter.
+      # @param normalize [Boolean] The flag indicating whether to normalize the hidden layer output or not.
+      # @param max_iter [Integer] The maximum number of iterations for finding centers.
+      # @param tol [Float] The tolerance of termination criterion for finding centers.
+      # @param random_seed [Integer] The seed value using to initialize the random generator.
+      def initialize(hidden_units: 128, gamma: nil, reg_param: 100.0, normalize: false,
+                     max_iter: 50, tol: 1e-4, 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 [RBFClassifier] 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)
+        raise 'RBFClassifier#fit requires Numo::Linalg but that is not loaded.' unless enable_linalg?(warning: false)
+
+        @classes = Numo::NArray[*y.to_a.uniq.sort]
+
+        partial_fit(x, one_hot_encode(y))
+
+        self
+      end
+
+      # Calculate confidence scores for samples.
+      #
+      # @param x [Numo::DFloat] (shape: [n_samples, n_features]) The samples to compute the scores.
+      # @return [Numo::DFloat] (shape: [n_samples, n_classes]) Confidence score per sample.
+      def decision_function(x)
+        x = ::Rumale::Validation.check_convert_sample_array(x)
+
+        h = hidden_output(x)
+        h.dot(@weight_vec)
+      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)
+
+        scores = decision_function(x)
+        n_samples, n_classes = scores.shape
+        label_ids = scores.max_index(axis: 1) - Numo::Int32.new(n_samples).seq * n_classes
+        @classes[label_ids].dup
+      end
+
+      private
+
+      def one_hot_encode(y)
+        Numo::DFloat.cast(::Rumale::Utils.binarize_labels(y))
+      end
+    end
+  end
+end

data/lib/rumale/neural_network/rbf_regressor.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+require 'rumale/base/regressor'
+require 'rumale/neural_network/base_rbf'
+require 'rumale/validation'
+
+module Rumale
+  module NeuralNetwork
+    # RBFRegressor is a class that implements regressor based on (k-means) radial basis function (RBF) networks.
+    #
+    # @example
+    #   require 'numo/tiny_linalg'
+    #   Numo::Linalg = Numo::TinyLinalg
+    #
+    #   require 'rumale/neural_network/rbf_regressor'
+    #
+    #   estimator = Rumale::NeuralNetwork::RBFRegressor.new(hidden_units: 128, reg_param: 100.0)
+    #   estimator.fit(training_samples, traininig_values)
+    #   results = estimator.predict(testing_samples)
+    #
+    # *Reference*
+    # - Bugmann, G., "Normalized Gaussian Radial Basis Function networks," Neural Computation, vol. 20, pp. 97--110, 1998.
+    # - Que, Q., and Belkin, M., "Back to the Future: Radial Basis Function Networks Revisited," Proc. of AISTATS'16, pp. 1375--1383, 2016.
+    class RBFRegressor < BaseRBF
+      include ::Rumale::Base::Regressor
+
+      # Return the centers in the hidden layer of RBF network.
+      # @return [Numo::DFloat] (shape: [n_centers, n_features])
+      attr_reader :centers
+
+      # Return the weight vector.
+      # @return [Numo::DFloat] (shape: [n_centers, n_outputs])
+      attr_reader :weight_vec
+
+      # Return the random generator.
+      # @return [Random]
+      attr_reader :rng
+
+      # Create a new regressor with (k-means) RBF networks.
+      #
+      # @param hidden_units [Array] The number of units in the hidden layer.
+      # @param gamma [Float] The parameter for the radial basis function, if nil it is 1 / n_features.
+      # @param reg_param [Float] The regularization parameter.
+      # @param normalize [Boolean] The flag indicating whether to normalize the hidden layer output or not.
+      # @param max_iter [Integer] The maximum number of iterations for finding centers.
+      # @param tol [Float] The tolerance of termination criterion for finding centers.
+      # @param random_seed [Integer] The seed value using to initialize the random generator.
+      def initialize(hidden_units: 128, gamma: nil, reg_param: 100.0, normalize: false,
+                     max_iter: 50, tol: 1e-4, 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)
+        raise 'RBFRegressor#fit requires Numo::Linalg but that is not loaded.' unless enable_linalg?(warning: false)
+
+        y = y.expand_dims(1) if y.ndim == 1
+
+        partial_fit(x, y)
+
+        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)
+
+        h = hidden_output(x)
+        out = h.dot(@weight_vec)
+        out = out[true, 0] if out.shape[1] == 1
+        out
+      end
+    end
+  end
+end

data/lib/rumale/neural_network/rvfl_classifier.rb

@@ -0,0 +1,108 @@
+# frozen_string_literal: true
+
+require 'rumale/base/classifier'
+require 'rumale/neural_network/base_rvfl'
+require 'rumale/utils'
+require 'rumale/validation'
+
+module Rumale
+  module NeuralNetwork
+    # RVFLClassifier is a class that implements classifier based on random vector functional link (RVFL) network.
+    # The current implementation uses sigmoid function as activation function.
+    #
+    # @example
+    #   require 'numo/tiny_linalg'
+    #   Numo::Linalg = Numo::TinyLinalg
+    #
+    #   require 'rumale/neural_network/rvfl_classifier'
+    #
+    #   estimator = Rumale::NeuralNetwork::RVFLClassifier.new(hidden_units: 128, reg_param: 100.0)
+    #   estimator.fit(training_samples, traininig_labels)
+    #   results = estimator.predict(testing_samples)
+    #
+    # *Reference*
+    # - Malik, A. K., Gao, R., Ganaie, M. A., Tanveer, M., and Suganthan, P. N., "Random vector functional link network: recent developments, applications, and future directions," Applied Soft Computing, vol. 143, 2023.
+    # - Zhang, L., and Suganthan, P. N., "A comprehensive evaluation of random vector functional link networks," Information Sciences, vol. 367--368, pp. 1094--1105, 2016.
+    class RVFLClassifier < BaseRVFL
+      include ::Rumale::Base::Classifier
+
+      # Return the class labels.
+      # @return [Numo::Int32] (size: n_classes)
+      attr_reader :classes
+
+      # Return the weight vector in the hidden layer of RVFL network.
+      # @return [Numo::DFloat] (shape: [n_hidden_units, n_features])
+      attr_reader :random_weight_vec
+
+      # Return the bias vector in the hidden layer of RVFL network.
+      # @return [Numo::DFloat] (shape: [n_hidden_units])
+      attr_reader :random_bias
+
+      # Return the weight vector.
+      # @return [Numo::DFloat] (shape: [n_features + n_hidden_units, n_classes])
+      attr_reader :weight_vec
+
+      # Return the random generator.
+      # @return [Random]
+      attr_reader :rng
+
+      # Create a new classifier with RVFL network.
+      #
+      # @param hidden_units [Array] The number of units in the hidden layer.
+      # @param reg_param [Float] The regularization parameter.
+      # @param scale [Float] The scale parameter for random weight and bias.
+      # @param random_seed [Integer] The seed value using to initialize the random generator.
+      def initialize(hidden_units: 128, reg_param: 100.0, scale: 1.0, 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 [RVFLClassifier] 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)
+        raise 'RVFLClassifier#fit requires Numo::Linalg but that is not loaded.' unless enable_linalg?(warning: false)
+
+        @classes = Numo::NArray[*y.to_a.uniq.sort]
+
+        partial_fit(x, one_hot_encode(y))
+
+        self
+      end
+
+      # Calculate confidence scores for samples.
+      #
+      # @param x [Numo::DFloat] (shape: [n_samples, n_features]) The samples to compute the scores.
+      # @return [Numo::DFloat] (shape: [n_samples, n_classes]) Confidence score per sample.
+      def decision_function(x)
+        x = ::Rumale::Validation.check_convert_sample_array(x)
+
+        h = hidden_output(x)
+        h.dot(@weight_vec)
+      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)
+
+        scores = decision_function(x)
+        n_samples, n_classes = scores.shape
+        label_ids = scores.max_index(axis: 1) - Numo::Int32.new(n_samples).seq * n_classes
+        @classes[label_ids].dup
+      end
+
+      private
+
+      def one_hot_encode(y)
+        Numo::DFloat.cast(::Rumale::Utils.binarize_labels(y))
+      end
+    end
+  end
+end

data/lib/rumale/neural_network/rvfl_regressor.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+require 'rumale/base/regressor'
+require 'rumale/neural_network/base_rvfl'
+require 'rumale/validation'
+
+module Rumale
+  module NeuralNetwork
+    # RVFLRegressor is a class that implements regressor based on random vector functional link (RVFL) network.
+    # The current implementation uses sigmoid function as activation function.
+    #
+    # @example
+    #   require 'numo/tiny_linalg'
+    #   Numo::Linalg = Numo::TinyLinalg
+    #
+    #   require 'rumale/neural_network/rvfl_regressor'
+    #
+    #   estimator = Rumale::NeuralNetwork::RVFLRegressor.new(hidden_units: 128, reg_param: 100.0)
+    #   estimator.fit(training_samples, traininig_values)
+    #   results = estimator.predict(testing_samples)
+    #
+    # *Reference*
+    # - Malik, A. K., Gao, R., Ganaie, M. A., Tanveer, M., and Suganthan, P. N., "Random vector functional link network: recent developments, applications, and future directions," Applied Soft Computing, vol. 143, 2023.
+    # - Zhang, L., and Suganthan, P. N., "A comprehensive evaluation of random vector functional link networks," Information Sciences, vol. 367--368, pp. 1094--1105, 2016.
+    class RVFLRegressor < BaseRVFL
+      include ::Rumale::Base::Regressor
+
+      # Return the weight vector in the hidden layer of RVFL network.
+      # @return [Numo::DFloat] (shape: [n_hidden_units, n_features])
+      attr_reader :random_weight_vec
+
+      # Return the bias vector in the hidden layer of RVFL network.
+      # @return [Numo::DFloat] (shape: [n_hidden_units])
+      attr_reader :random_bias
+
+      # Return the weight vector.
+      # @return [Numo::DFloat] (shape: [n_features + n_hidden_units, n_outputs])
+      attr_reader :weight_vec
+
+      # Return the random generator.
+      # @return [Random]
+      attr_reader :rng
+
+      # Create a new regressor with RVFL network.
+      #
+      # @param hidden_units [Array] The number of units in the hidden layer.
+      # @param reg_param [Float] The regularization parameter.
+      # @param scale [Float] The scale parameter for random weight and bias.
+      # @param random_seed [Integer] The seed value using to initialize the random generator.
+      def initialize(hidden_units: 128, reg_param: 100.0, scale: 1.0, 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 [RVFLRegressor] 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)
+        raise 'RVFLRegressor#fit requires Numo::Linalg but that is not loaded.' unless enable_linalg?(warning: false)
+
+        y = y.expand_dims(1) if y.ndim == 1
+
+        partial_fit(x, y)
+
+        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]) The predicted values per sample.
+      def predict(x)
+        x = ::Rumale::Validation.check_convert_sample_array(x)
+
+        h = hidden_output(x)
+        out = h.dot(@weight_vec)
+        out = out[true, 0] if out.shape[1] == 1
+        out
+      end
+    end
+  end
+end

data/lib/rumale/neural_network/version.rb

@@ -5,6 +5,6 @@ module Rumale
   # This module consists of the modules and classes for implementation multi-layer perceptron estimator.
   module NeuralNetwork
     # @!visibility private
-    VERSION = '0.27.0'
+    VERSION = '0.28.0'
   end
 end

data/lib/rumale/neural_network.rb

@@ -7,3 +7,9 @@ require_relative 'neural_network/version'
 require_relative 'neural_network/base_mlp'
 require_relative 'neural_network/mlp_classifier'
 require_relative 'neural_network/mlp_regressor'
+require_relative 'neural_network/base_rbf'
+require_relative 'neural_network/rbf_classifier'
+require_relative 'neural_network/rbf_regressor'
+require_relative 'neural_network/base_rvfl'
+require_relative 'neural_network/rvfl_classifier'
+require_relative 'neural_network/rvfl_regressor'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rumale-neural_network
 version: !ruby/object:Gem::Version
-  version: 0.27.0
+  version: 0.28.0
 platform: ruby
 authors:
 - yoshoku
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2023-08-26 00:00:00.000000000 Z
+date: 2023-11-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: numo-narray
@@ -30,14 +30,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.27.0
+        version: 0.28.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.27.0
+        version: 0.28.0
 description: |
   Rumale::NeuralNetwork provides classifier and regression
   based on multi-layer perceptron with Rumale interface.
@@ -51,8 +51,14 @@ files:
 - README.md
 - lib/rumale/neural_network.rb
 - lib/rumale/neural_network/base_mlp.rb
+- lib/rumale/neural_network/base_rbf.rb
+- lib/rumale/neural_network/base_rvfl.rb
 - lib/rumale/neural_network/mlp_classifier.rb
 - lib/rumale/neural_network/mlp_regressor.rb
+- lib/rumale/neural_network/rbf_classifier.rb
+- lib/rumale/neural_network/rbf_regressor.rb
+- lib/rumale/neural_network/rvfl_classifier.rb
+- lib/rumale/neural_network/rvfl_regressor.rb
 - lib/rumale/neural_network/version.rb
 homepage: https://github.com/yoshoku/rumale
 licenses:
@@ -78,7 +84,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.3.26
+rubygems_version: 3.4.20
 signing_key:
 specification_version: 4
 summary: Rumale::NeuralNetwork provides classifier and regression based on multi-layer