rumale-naive_bayes 0.24.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 6099259a89800806a4c1cb97f2c6fd76d9a3ee3c06bfafbd26ff585ce029bc8d
+  data.tar.gz: bd77f90edab0d920bb9bda3c9c2e21b3fd7fde646c56d7700d131c2eba2005c0
+SHA512:
+  metadata.gz: 878ef0a8d13a8df2cb0b27c8f87db50572c7ba7b81ab4ad5840bf6c263a2cc607e3dd12273c630f869df754be9edd69339364f927b33817ec3d17749fc76f74f
+  data.tar.gz: fcf815a1f21e9db918f898ee9d917948c1737ab2b66f1dd043c2f3b49d1b340fd40b933c0a1c31ec466a5fd3cbd94bf9dc821bb31f8a1a137bb573327b195799

data/LICENSE.txt

@@ -0,0 +1,27 @@
+Copyright (c) 2022 Atsushi Tatsuma
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+* Redistributions of source code must retain the above copyright notice, this
+  list of conditions and the following disclaimer.
+
+* Redistributions in binary form must reproduce the above copyright notice,
+  this list of conditions and the following disclaimer in the documentation
+  and/or other materials provided with the distribution.
+
+* Neither the name of the copyright holder nor the names of its
+  contributors may be used to endorse or promote products derived from
+  this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

data/README.md

@@ -0,0 +1,34 @@
+# Rumale::NaiveBayes
+
+[![Gem Version](https://badge.fury.io/rb/rumale-naive_bayes.svg)](https://badge.fury.io/rb/rumale-naive_bayes)
+[![BSD 3-Clause License](https://img.shields.io/badge/License-BSD%203--Clause-orange.svg)](https://github.com/yoshoku/rumale/blob/main/rumale-naive_bayes/LICENSE.txt)
+[![Documentation](https://img.shields.io/badge/api-reference-blue.svg)](https://yoshoku.github.io/rumale/doc/Rumale/NaiveBayes.html)
+
+Rumale is a machine learning library in Ruby.
+Rumale::NaiveBayes provides naive bayes models,
+such as Gaussian Naive Bayes, Multinomial Naive Bayes, and Bernoulli Naive Bayes,
+with Rumale interface.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'rumale-naive_bayes'
+```
+
+And then execute:
+
+    $ bundle install
+
+Or install it yourself as:
+
+    $ gem install rumale-naive_bayes
+
+## Documentation
+
+- [Rumale API Documentation - NaiveBayes](https://yoshoku.github.io/rumale/doc/Rumale/NaiveBayes.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/naive_bayes/base_naive_bayes.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+require 'rumale/base/estimator'
+require 'rumale/base/classifier'
+require 'rumale/validation'
+
+module Rumale
+  module NaiveBayes
+    # BaseNaiveBayes is a class that has methods for common processes of naive bayes classifier.
+    # This class is used internally.
+    class BaseNaiveBayes < ::Rumale::Base::Estimator
+      include ::Rumale::Base::Classifier
+
+      def initialize # rubocop:disable Lint/UselessMethodDefinition
+        super()
+      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.first
+        decision_values = decision_function(x)
+        Numo::Int32.asarray(Array.new(n_samples) { |n| @classes[decision_values[n, true].max_index] })
+      end
+
+      # Predict log-probability for samples.
+      #
+      # @param x [Numo::DFloat] (shape: [n_samples, n_features]) The samples to predict the log-probailities.
+      # @return [Numo::DFloat] (shape: [n_samples, n_classes]) Predicted log-probability of each class per sample.
+      def predict_log_proba(x)
+        x = ::Rumale::Validation.check_convert_sample_array(x)
+
+        n_samples, = x.shape
+        log_likelihoods = decision_function(x)
+        log_likelihoods - Numo::NMath.log(Numo::NMath.exp(log_likelihoods).sum(axis: 1)).reshape(n_samples, 1)
+      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)
+
+        Numo::NMath.exp(predict_log_proba(x)).abs
+      end
+    end
+  end
+end

data/lib/rumale/naive_bayes/bernoulli_nb.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+require 'rumale/naive_bayes/base_naive_bayes'
+
+module Rumale
+  module NaiveBayes
+    # BernoulliNB is a class that implements Bernoulli Naive Bayes classifier.
+    #
+    # @example
+    #   require 'rumale/naive_bayes/bernoulli_nb'
+    #
+    #   estimator = Rumale::NaiveBayes::BernoulliNB.new(smoothing_param: 1.0, bin_threshold: 0.0)
+    #   estimator.fit(training_samples, training_labels)
+    #   results = estimator.predict(testing_samples)
+    #
+    # *Reference*
+    # - Manning, C D., Raghavan, P., and Schutze, H., "Introduction to Information Retrieval," Cambridge University Press., 2008.
+    class BernoulliNB < BaseNaiveBayes
+      # Return the class labels.
+      # @return [Numo::Int32] (size: n_classes)
+      attr_reader :classes
+
+      # Return the prior probabilities of the classes.
+      # @return [Numo::DFloat] (shape: [n_classes])
+      attr_reader :class_priors
+
+      # Return the conditional probabilities for features of each class.
+      # @return [Numo::DFloat] (shape: [n_classes, n_features])
+      attr_reader :feature_probs
+
+      # Create a new classifier with Bernoulli Naive Bayes.
+      #
+      # @param smoothing_param [Float] The Laplace smoothing parameter.
+      # @param bin_threshold [Float] The threshold for binarizing of features.
+      def initialize(smoothing_param: 1.0, bin_threshold: 0.0)
+        super()
+        @params = {
+          smoothing_param: smoothing_param,
+          bin_threshold: bin_threshold
+        }
+      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 categorical variables (e.g. labels)
+      #   to be used for fitting the model.
+      # @return [BernoulliNB] 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_samples, = x.shape
+        bin_x = Numo::DFloat[*x.gt(@params[:bin_threshold])]
+        @classes = Numo::Int32[*y.to_a.uniq.sort]
+        n_samples_each_class = Numo::DFloat[*@classes.to_a.map { |l| y.eq(l).count.to_f }]
+        @class_priors = n_samples_each_class / n_samples
+        count_features = Numo::DFloat[*@classes.to_a.map { |l| bin_x[y.eq(l).where, true].sum(axis: 0) }]
+        count_features += @params[:smoothing_param]
+        n_samples_each_class += 2.0 * @params[:smoothing_param]
+        n_classes = @classes.size
+        @feature_probs = count_features / n_samples_each_class.reshape(n_classes, 1)
+        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 scores per sample for each class.
+      def decision_function(x)
+        x = ::Rumale::Validation.check_convert_sample_array(x)
+
+        n_classes = @classes.size
+        bin_x = Numo::DFloat[*x.gt(@params[:bin_threshold])]
+        not_bin_x = Numo::DFloat[*x.le(@params[:bin_threshold])]
+        log_likelihoods = Array.new(n_classes) do |l|
+          Math.log(@class_priors[l]) + (
+            (Numo::DFloat[*bin_x] * Numo::NMath.log(@feature_probs[l, true])).sum(axis: 1)
+            (Numo::DFloat[*not_bin_x] * Numo::NMath.log(1.0 - @feature_probs[l, true])).sum(axis: 1))
+        end
+        Numo::DFloat[*log_likelihoods].transpose.dup
+      end
+    end
+  end
+end

data/lib/rumale/naive_bayes/complement_nb.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+require 'rumale/naive_bayes/base_naive_bayes'
+
+module Rumale
+  module NaiveBayes
+    # ComplementNB is a class that implements Complement Naive Bayes classifier.
+    #
+    # @example
+    #   require 'rumale/naive_bayes/complement_nb'
+    #
+    #   estimator = Rumale::NaiveBayes::ComplementNB.new(smoothing_param: 1.0)
+    #   estimator.fit(training_samples, training_labels)
+    #   results = estimator.predict(testing_samples)
+    #
+    # *Reference*
+    # - Rennie, J. D. M., Shih, L., Teevan, J., and Karger, D. R., "Tackling the Poor Assumptions of Naive Bayes Text Classifiers," ICML' 03, pp. 616--623, 2013.
+    class ComplementNB < BaseNaiveBayes
+      # Return the class labels.
+      # @return [Numo::Int32] (size: n_classes)
+      attr_reader :classes
+
+      # Return the prior probabilities of the classes.
+      # @return [Numo::DFloat] (shape: [n_classes])
+      attr_reader :class_priors
+
+      # Return the conditional probabilities for features of each class.
+      # @return [Numo::DFloat] (shape: [n_classes, n_features])
+      attr_reader :feature_probs
+
+      # Create a new classifier with Complement Naive Bayes.
+      #
+      # @param smoothing_param [Float] The smoothing parameter.
+      # @param norm [Boolean] The flag indicating whether to normlize the weight vectors.
+      def initialize(smoothing_param: 1.0, norm: false)
+        super()
+        @params = {
+          smoothing_param: smoothing_param,
+          norm: norm
+        }
+      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 categorical variables (e.g. labels)
+      #   to be used for fitting the model.
+      # @return [ComplementNB] 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_samples, = x.shape
+        @classes = Numo::Int32[*y.to_a.uniq.sort]
+        @class_priors = Numo::DFloat[*@classes.to_a.map { |l| y.eq(l).count.fdiv(n_samples) }]
+        @class_log_probs = Numo::NMath.log(@class_priors)
+        compl_features = Numo::DFloat[*@classes.to_a.map { |l| x[y.ne(l).where, true].sum(axis: 0) }]
+        compl_features += @params[:smoothing_param]
+        n_classes = @classes.size
+        @feature_probs = compl_features / compl_features.sum(axis: 1).reshape(n_classes, 1)
+        feature_log_probs = Numo::NMath.log(@feature_probs)
+        @weights = if normalize?
+                     feature_log_probs / feature_log_probs.sum(axis: 1).reshape(n_classes, 1)
+                   else
+                     -feature_log_probs
+                   end
+        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 scores per sample for each class.
+      def decision_function(x)
+        x = ::Rumale::Validation.check_convert_sample_array(x)
+
+        @class_log_probs + x.dot(@weights.transpose)
+      end
+
+      private
+
+      def normalize?
+        @params[:norm] == true
+      end
+    end
+  end
+end

data/lib/rumale/naive_bayes/gaussian_nb.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+require 'rumale/naive_bayes/base_naive_bayes'
+
+module Rumale
+  module NaiveBayes
+    # GaussianNB is a class that implements Gaussian Naive Bayes classifier.
+    #
+    # @example
+    #   require 'rumale/naive_bayes/gaussian_nb'
+    #
+    #   estimator = Rumale::NaiveBayes::GaussianNB.new
+    #   estimator.fit(training_samples, training_labels)
+    #   results = estimator.predict(testing_samples)
+    class GaussianNB < BaseNaiveBayes
+      # Return the class labels.
+      # @return [Numo::Int32] (size: n_classes)
+      attr_reader :classes
+
+      # Return the prior probabilities of the classes.
+      # @return [Numo::DFloat] (shape: [n_classes])
+      attr_reader :class_priors
+
+      # Return the mean vectors of the classes.
+      # @return [Numo::DFloat] (shape: [n_classes, n_features])
+      attr_reader :means
+
+      # Return the variance vectors of the classes.
+      # @return [Numo::DFloat] (shape: [n_classes, n_features])
+      attr_reader :variances
+
+      # Create a new classifier with Gaussian Naive Bayes.
+      def initialize
+        super()
+        @params = {}
+      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 categorical variables (e.g. labels)
+      #   to be used for fitting the model.
+      # @return [GaussianNB] 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_samples, = x.shape
+        @classes = Numo::Int32[*y.to_a.uniq.sort]
+        @class_priors = Numo::DFloat[*@classes.to_a.map { |l| y.eq(l).count / n_samples.to_f }]
+        @means = Numo::DFloat[*@classes.to_a.map { |l| x[y.eq(l).where, true].mean(0) }]
+        @variances = Numo::DFloat[*@classes.to_a.map { |l| x[y.eq(l).where, true].var(0) }]
+        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 scores per sample for each class.
+      def decision_function(x)
+        x = ::Rumale::Validation.check_convert_sample_array(x)
+
+        n_classes = @classes.size
+        log_likelihoods = Array.new(n_classes) do |l|
+          Math.log(@class_priors[l]) - 0.5 * (
+            Numo::NMath.log(2.0 * Math::PI * @variances[l, true]) +
+            ((x - @means[l, true])**2 / @variances[l, true])).sum(axis: 1)
+        end
+        Numo::DFloat[*log_likelihoods].transpose.dup
+      end
+    end
+  end
+end

data/lib/rumale/naive_bayes/multinomial_nb.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+require 'rumale/naive_bayes/base_naive_bayes'
+
+module Rumale
+  module NaiveBayes
+    # MultinomialNB is a class that implements Multinomial Naive Bayes classifier.
+    #
+    # @example
+    #   require 'rumale/naive_bayes/multinomial_nb'
+    #
+    #   estimator = Rumale::NaiveBayes::MultinomialNB.new(smoothing_param: 1.0)
+    #   estimator.fit(training_samples, training_labels)
+    #   results = estimator.predict(testing_samples)
+    #
+    # *Reference*
+    # - Manning, C D., Raghavan, P., and Schutze, H., "Introduction to Information Retrieval," Cambridge University Press., 2008.
+    class MultinomialNB < BaseNaiveBayes
+      # Return the class labels.
+      # @return [Numo::Int32] (size: n_classes)
+      attr_reader :classes
+
+      # Return the prior probabilities of the classes.
+      # @return [Numo::DFloat] (shape: [n_classes])
+      attr_reader :class_priors
+
+      # Return the conditional probabilities for features of each class.
+      # @return [Numo::DFloat] (shape: [n_classes, n_features])
+      attr_reader :feature_probs
+
+      # Create a new classifier with Multinomial Naive Bayes.
+      #
+      # @param smoothing_param [Float] The Laplace smoothing parameter.
+      def initialize(smoothing_param: 1.0)
+        super()
+        @params = { smoothing_param: smoothing_param }
+      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 categorical variables (e.g. labels)
+      #   to be used for fitting the model.
+      # @return [MultinomialNB] 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_samples, = x.shape
+        @classes = Numo::Int32[*y.to_a.uniq.sort]
+        @class_priors = Numo::DFloat[*@classes.to_a.map { |l| y.eq(l).count / n_samples.to_f }]
+        count_features = Numo::DFloat[*@classes.to_a.map { |l| x[y.eq(l).where, true].sum(axis: 0) }]
+        count_features += @params[:smoothing_param]
+        n_classes = @classes.size
+        @feature_probs = count_features / count_features.sum(axis: 1).reshape(n_classes, 1)
+        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 scores per sample for each class.
+      def decision_function(x)
+        x = ::Rumale::Validation.check_convert_sample_array(x)
+
+        n_classes = @classes.size
+        bin_x = x.gt(0)
+        log_likelihoods = Array.new(n_classes) do |l|
+          Math.log(@class_priors[l]) + (Numo::DFloat[*bin_x] * Numo::NMath.log(@feature_probs[l, true])).sum(axis: 1)
+        end
+        Numo::DFloat[*log_likelihoods].transpose.dup
+      end
+    end
+  end
+end

data/lib/rumale/naive_bayes/negation_nb.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+require 'rumale/naive_bayes/base_naive_bayes'
+
+module Rumale
+  module NaiveBayes
+    # NegationNB is a class that implements Negation Naive Bayes classifier.
+    #
+    # @example
+    #   require 'rumale/naive_bayes/negation_nb'
+    #
+    #   estimator = Rumale::NaiveBayes::NegationNB.new(smoothing_param: 1.0)
+    #   estimator.fit(training_samples, training_labels)
+    #   results = estimator.predict(testing_samples)
+    #
+    # *Reference*
+    # - Komiya, K., Sato, N., Fujimoto, K., and Kotani, Y., "Negation Naive Bayes for Categorization of Product Pages on the Web," RANLP' 11, pp. 586--592, 2011.
+    class NegationNB < BaseNaiveBayes
+      # Return the class labels.
+      # @return [Numo::Int32] (size: n_classes)
+      attr_reader :classes
+
+      # Return the prior probabilities of the classes.
+      # @return [Numo::DFloat] (shape: [n_classes])
+      attr_reader :class_priors
+
+      # Return the conditional probabilities for features of each class.
+      # @return [Numo::DFloat] (shape: [n_classes, n_features])
+      attr_reader :feature_probs
+
+      # Create a new classifier with Complement Naive Bayes.
+      #
+      # @param smoothing_param [Float] The smoothing parameter.
+      def initialize(smoothing_param: 1.0)
+        super()
+        @params = { smoothing_param: smoothing_param }
+      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 categorical variables (e.g. labels)
+      #   to be used for fitting the model.
+      # @return [ComplementNB] 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_samples, = x.shape
+        @classes = Numo::Int32[*y.to_a.uniq.sort]
+        @class_priors = Numo::DFloat[*@classes.to_a.map { |l| y.eq(l).count.fdiv(n_samples) }]
+        @class_log_probs = Numo::NMath.log(1 / (1 - @class_priors))
+        compl_features = Numo::DFloat[*@classes.to_a.map { |l| x[y.ne(l).where, true].sum(axis: 0) }]
+        compl_features += @params[:smoothing_param]
+        n_classes = @classes.size
+        @feature_probs = compl_features / compl_features.sum(axis: 1).reshape(n_classes, 1)
+        @weights = Numo::NMath.log(@feature_probs)
+        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 scores per sample for each class.
+      def decision_function(x)
+        x = ::Rumale::Validation.check_convert_sample_array(x)
+
+        @class_log_probs - x.dot(@weights.transpose)
+      end
+    end
+  end
+end

data/lib/rumale/naive_bayes/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 classes that implement naive bayes models.
+  module NaiveBayes
+    # @!visibility private
+    VERSION = '0.24.0'
+  end
+end

data/lib/rumale/naive_bayes.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+require 'numo/narray'
+
+require_relative 'naive_bayes/base_naive_bayes'
+require_relative 'naive_bayes/bernoulli_nb'
+require_relative 'naive_bayes/complement_nb'
+require_relative 'naive_bayes/gaussian_nb'
+require_relative 'naive_bayes/multinomial_nb'
+require_relative 'naive_bayes/negation_nb'
+require_relative 'naive_bayes/version'

metadata

@@ -0,0 +1,89 @@
+--- !ruby/object:Gem::Specification
+name: rumale-naive_bayes
+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::NaiveBayes provides naive bayes models,
+  such as Gaussian Naive Bayes, Multinomial Naive Bayes, and Bernoulli Naive Bayes,
+  with Rumale interface.
+email:
+- yoshoku@outlook.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE.txt
+- README.md
+- lib/rumale/naive_bayes.rb
+- lib/rumale/naive_bayes/base_naive_bayes.rb
+- lib/rumale/naive_bayes/bernoulli_nb.rb
+- lib/rumale/naive_bayes/complement_nb.rb
+- lib/rumale/naive_bayes/gaussian_nb.rb
+- lib/rumale/naive_bayes/multinomial_nb.rb
+- lib/rumale/naive_bayes/negation_nb.rb
+- lib/rumale/naive_bayes/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-naive_bayes
+  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::NaiveBayes provides naive bayes models with Rumale interface.
+test_files: []