nbayes 0.1.1 → 0.1.3

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: c4c286395465f5e97e4ecba9407ce021039e2809
+  data.tar.gz: 7ac74a9b05b4fcfb1051a9a9ed2359c860b8564e
+SHA512:
+  metadata.gz: 6359cc15db183b65f376062297c9c1f143befd795365d969b92f0ea55fd831a3c93aba8247f52fa3da1e6348a5f7aedff85bec3b52f3d7da204c0bb5a79bfbca
+  data.tar.gz: ee66196fab0c55a70557947dac32005c868451ec2b4032b64cc2c9c2ee3da8eafe14fb13ab8ad968fba7ebd30352e9eb1619dc96e646fa6bfe0d862cbd089074

data/Gemfile

@@ -6,9 +6,9 @@ source "http://rubygems.org"
 # Add dependencies to develop your gem here.
 # Include everything needed to run rake, tests, features, etc.
 group :development do
-  gem "rspec", ">= 2.8.0"
-  gem "rdoc", ">= 3.12"
-  gem "bundler", ">= 1.0.0"
-  gem "jeweler", ">= 1.8.3"
+  gem "rspec", ">= 3.9.0"
+  gem "rdoc", ">= 3.0.0"
+  gem "bundler", ">= 2.0.0"
+  gem "jeweler", ">= 2.3.0"
 end
 gem 'simplecov', :require => false, :group => :test

data/LICENSE.txt

@@ -1,4 +1,4 @@
-Copyright (c) 2012 Oasic Technologies LLC
+Copyright (c) 2012-2016 Oasic Technologies LLC
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the

data/{README.rdoc → README.md}

@@ -1,8 +1,10 @@
-== nbayes
+# nbayes
 
-_gem install nbayes_
+```
+gem install nbayes
+```
 
-NBayes is a full-featured, Ruby implementation of Naive Bayes.  Some of the features include:
+NBayes is a full-featured, Ruby implementation of ``Naive Bayes``.  Some of the features include:
 
 * allows prior distribution on classes to be assumed uniform (optional)
 * generic to work with all types of tokens, not just text
@@ -14,7 +16,7 @@ NBayes is a full-featured, Ruby implementation of Naive Bayes.  Some of the feat
 
 For more information, view this blog post: http://blog.oasic.net/2012/06/naive-bayes-for-ruby.html
 
-== Contributing to nbayes
+## Contributing to nbayes
  
 * Check out the latest master to make sure the feature hasn't been implemented or the bug hasn't been fixed yet.
 * Check out the issue tracker to make sure someone already hasn't requested it and/or contributed it.
@@ -24,8 +26,12 @@ For more information, view this blog post: http://blog.oasic.net/2012/06/naive-b
 * Make sure to add tests for it. This is important so I don't break it in a future version unintentionally.
 * Please try not to mess with the Rakefile, version, or history. If you want to have your own version, or is otherwise necessary, that is fine, but please isolate to its own commit so I can cherry-pick around it.
 
-== Copyright
+## Acknowledgements
 
-Copyright (c) 2012 Oasic Technologies LLC. See LICENSE.txt for
-further details.
+This project is supported by the GrammarBot [grammar checker](http://www.GrammarBot.io/)
+
+
+## Copyright
+
+Copyright (c) 2012-2020 Oasic Technologies LLC. See LICENSE.txt for further details.
 

data/VERSION

@@ -1 +1 @@
-0.1.1
+0.1.3

data/lib/nbayes.rb

@@ -8,24 +8,44 @@ require 'yaml'
 # - allows binarized or standard NB
 # - allows Prior distribution on category to be assumed uniform (optional)
 # - generic to work with all types of tokens, not just text
-#
+
 
 module NBayes
 
-  class Base
+  class Vocab
+    attr_accessor :log_size, :tokens
 
-    attr_accessor :assume_uniform, :debug, :k, :vocab, :data, :log_vocab
-    attr_reader :binarized
+    def initialize(options = {})
+      @tokens = Hash.new
+      # for smoothing, use log of vocab size, rather than vocab size
+      @log_size = options[:log_size]
+    end
 
-    def initialize(options={})
-      @debug = false
-      @k = 1
-      @binarized = options[:binarized] || false
-      @log_vocab = false    				# for smoothing, use log of vocab size, rather than vocab size 
-      @assume_uniform = false
-      @vocab = Hash.new                   		# used to calculate vocab size (@vocab.keys.length)
+    def delete(token)
+      tokens.delete(token)
+    end
+
+    def each(&block)
+      tokens.keys.each(&block)
+    end
+
+    def size
+      if log_size
+        Math.log(tokens.count)
+      else
+        tokens.count
+      end
+    end
+
+    def seen_token(token)
+      tokens[token] = 1
+    end
+  end
+
+  class Data
+    attr_accessor :data
+    def initialize(options = {})
       @data = Hash.new
-      @data.default_proc = get_default_proc()
       #@data = {
       #  "category1": {
       #    "tokens": Hash.new(0),
@@ -36,82 +56,199 @@ module NBayes
       #}
     end
 
+    def categories
+      data.keys
+    end
+
+    def token_trained?(token, category)
+      data[category] ? data[category][:tokens].has_key?(token) : false
+    end
+
+    def cat_data(category)
+      unless data[category].is_a? Hash
+        data[category] = new_category
+      end
+      data[category]
+    end
+
+    def category_stats
+      tmp = []
+      total_example_count = total_examples
+      self.each do |category|
+        e = example_count(category)
+        t = token_count(category)
+        tmp << "For category #{category}, %d examples (%.02f%% of the total) and %d total_tokens" % [e, 100.0 * e / total_example_count, t]
+      end
+      tmp.join("\n")
+    end
+
+    def each(&block)
+      data.keys.each(&block)
+    end
+
+    # Increment the number of training examples for this category
+    def increment_examples(category)
+      cat_data(category)[:examples] += 1
+    end
+
+    # Decrement the number of training examples for this category.
+    # Delete the category if the examples counter is 0.
+    def decrement_examples(category)
+      cat_data(category)[:examples] -= 1
+      delete_category(category) if cat_data(category)[:examples] < 1
+    end
+
+    def example_count(category)
+      cat_data(category)[:examples]
+    end
+
+    def token_count(category)
+      cat_data(category)[:total_tokens]
+    end
+
+    # XXX - Add Enumerable and see if I get inject?
+    # Total number of training instances
+    def total_examples
+      sum = 0
+      self.each {|category| sum += example_count(category) }
+      sum
+    end
+
+    # Add this token to this category
+    def add_token_to_category(category, token)
+      cat_data(category)[:tokens][token] += 1
+      cat_data(category)[:total_tokens] += 1
+    end
+
+    # Decrement the token counter in a category
+    # If the counter is 0, delete the token.
+    # If the total number of tokens is 0, delete the category.
+    def remove_token_from_category(category, token)
+      cat_data(category)[:tokens][token] -= 1
+      delete_token_from_category(category, token) if cat_data(category)[:tokens][token] < 1
+      cat_data(category)[:total_tokens] -= 1
+      delete_category(category) if cat_data(category)[:total_tokens] < 1
+    end
+
+    # How many times does this token appear in this category?
+    def count_of_token_in_category(category, token)
+      cat_data(category)[:tokens][token]
+    end
+
+    def delete_token_from_category(category, token)
+      count = count_of_token_in_category(category, token)
+      cat_data(category)[:tokens].delete(token)
+      # Update this category's total token count
+      cat_data(category)[:total_tokens] -= count
+    end
+
+    def purge_less_than(token, x)
+      return if token_count_across_categories(token) >= x
+      self.each do |category|
+        delete_token_from_category(category, token)
+      end
+      true  # Let caller know we removed this token
+    end
+
+    # XXX - TODO - use count_of_token_in_category
+    # Return the total number of tokens we've seen across all categories
+    def token_count_across_categories(token)
+      data.keys.inject(0){|sum, cat| sum + @data[cat][:tokens][token] }
+    end
+
+    def reset_after_import
+      self.each {|category| cat_data(category)[:tokens].default = 0 }
+    end
+
+    def new_category
+      {
+        :tokens => Hash.new(0),             # holds freq counts
+        :total_tokens => 0,
+        :examples => 0
+      }
+    end
+
+    def delete_category(category)
+      data.delete(category) if data.has_key?(category)
+      categories
+    end
+
+  end
+
+  class Base
+
+    attr_accessor :assume_uniform, :debug, :k, :vocab, :data
+    attr_reader :binarized
+
+    def initialize(options={})
+      @debug = false
+      @k = 1
+      @binarized = options[:binarized] || false
+      @assume_uniform = false
+      @vocab = Vocab.new(:log_size => options[:log_vocab])
+      @data = Data.new
+    end
 
     # Allows removal of low frequency words that increase processing time and may overfit
     # - tokens with a count less than x (measured by summing across all classes) are removed
     # Ex: nb.purge_less_than(2)
     #
-    # NOTE: this does not decrement the "examples" count, so purging is not *always* the same 
-    #  as if the item was never added in the first place, but usually so
+    # NOTE: this does not decrement the "examples" count, so purging is not *always* the same
+    # as if the item was never added in the first place, but usually so
     def purge_less_than(x)
       remove_list = {}
-      @vocab.keys.each do |token|
-	count = @data.keys.inject(0){|sum, cat| sum + @data[cat][:tokens][token] }
-	next if count >= x
-	@data.each do |cat, cat_data|
-	  count = cat_data[:tokens][token]
-	  cat_data[:tokens].delete(token) 		# delete and retrieve count
-	  cat_data[:total_tokens] -= count                # subtract that count from cat counts
-	end  # each category hash
-	#print "removing #{token}\n"
-	remove_list[token]=1
+      @vocab.each do |token|
+        if data.purge_less_than(token, x)
+          # print "removing #{token}\n"
+          remove_list[token] = 1
+        end
       end  # each vocab word
       remove_list.keys.each {|token| @vocab.delete(token) }
-      #print "total vocab size is now #{vocab_size}\n" 
+      # print "total vocab size is now #{vocab.size}\n"
     end
 
-
-    # Returns the default proc used by the data hash
-    # Separate method so that it can be used after data import
-    def get_default_proc
-      return lambda do |hash, category|
-	hash[category]= {
-	  :tokens => Hash.new(0),         		# holds freq counts
-	  :total_tokens => 0,
-	  :examples => 0
-	}
-      end
+    # Delete an entire category from the classification data
+    def delete_category(category)
+      data.delete_category(category)
     end
 
-    # called internally after yaml import to reset Hash defaults
-    def reset_after_import
-      @data.default_proc = get_default_proc()
-      @data.each {|cat, cat_hash| cat_hash[:tokens].default=0 }
+    def train(tokens, category)
+      tokens = tokens.uniq if binarized
+      data.increment_examples(category)
+      tokens.each do |token|
+        vocab.seen_token(token)
+        data.add_token_to_category(category, token)
+      end
     end
 
-    def train(tokens, category)
-      cat_data = @data[category]
-      cat_data[:examples]+=1
-      tokens = tokens.uniq  if binarized
-      tokens.each do |w|
-	@vocab[w]=1
-	cat_data[:tokens][w]+=1
-	cat_data[:total_tokens]+=1
+    # Be carefull with this function:
+    # * It decrement the number of examples for the category.
+    #   If the being-untrained category has no more examples, it is removed from the category list.
+    # * It untrain already trained tokens, non existing tokens are not considered.
+    def untrain(tokens, category)
+      tokens = tokens.uniq if binarized
+      data.decrement_examples(category)
+      
+      tokens.each do |token|
+        if data.token_trained?(token, category)
+          vocab.delete(token)
+          data.remove_token_from_category(category, token)
+        end
       end
     end
 
     def classify(tokens)
       print "classify: #{tokens.join(', ')}\n" if @debug
       probs = {}
-      tokens = tokens.uniq  if binarized
+      tokens = tokens.uniq if binarized
       probs = calculate_probabilities(tokens)
       print "results: #{probs.to_yaml}\n" if @debug
       probs.extend(NBayes::Result)
       probs
     end
 
-    # Total number of training instances
-    def total_examples
-      sum = 0
-      @data.each {|cat, cat_data| sum += cat_data[:examples] }
-      sum
-    end
-
-    # Returns the size of the "vocab" - the number of unique tokens found in the text
-    # This is used in the Laplacian smoothing.
-    def vocab_size
-      return Math.log(@vocab.keys.length)  if @log_vocab
-      @vocab.keys.length
+    def category_stats
+      data.category_stats
     end
 
     # Calculates the actual probability of a class given the tokens
@@ -119,21 +256,31 @@ module NBayes
     def calculate_probabilities(tokens)
       # P(class|words) = P(w1,...,wn|class) * P(class) / P(w1,...,wn)
       #                = argmax P(w1,...,wn|class) * P(class)
-      # 
+      #
       # P(wi|class) = (count(wi, class) + k)/(count(w,class) + kV)
       prob_numerator = {}
-      v_size = vocab_size
-      @data.keys.each do |category|
-	cat_data = @data[category]
-	cat_prob = Math.log(cat_data[:examples]/total_examples().to_f)
-	cat_prob = Math.log(1/@data.keys.length.to_f)  if assume_uniform
-	log_probs = 0
-	cat_denominator = (cat_data[:total_tokens]+ @k*v_size).to_f
-	tokens.each do |token|
-	  log_probs += Math.log( (cat_data[:tokens][token] + @k)/cat_denominator )
-	end
-	prob_numerator[category] = log_probs + cat_prob
+      v_size = vocab.size
+
+      cat_prob = Math.log(1 / data.categories.count.to_f)
+      total_example_count = data.total_examples.to_f
+
+      data.each do |category|
+        unless assume_uniform
+          cat_prob = Math.log(data.example_count(category) / total_example_count)
+        end
+
+        log_probs = 0
+        denominator = (data.token_count(category) + @k * v_size).to_f
+        tokens.each do |token|
+          numerator = data.count_of_token_in_category(category, token) + @k
+          log_probs += Math.log( numerator / denominator )
+        end
+        prob_numerator[category] = log_probs + cat_prob
       end
+      normalize(prob_numerator)
+    end
+
+    def normalize(prob_numerator)
       # calculate the denominator, which normalizes this into a probability; it's just the sum of all numerators from above
       normalizer = 0
       prob_numerator.each {|cat, numerator| normalizer += numerator }
@@ -148,37 +295,47 @@ module NBayes
       intermed = {}
       renormalizer = 0
       prob_numerator.each do |cat, numerator|
-	intermed[cat]=normalizer/numerator.to_f
-	renormalizer += intermed[cat]
+        intermed[cat] = normalizer / numerator.to_f
+        renormalizer += intermed[cat]
       end
       # calculate final probs
       final_probs = {}
       intermed.each do |cat, value|
-	final_probs[cat]=value/renormalizer.to_f
+        final_probs[cat] = value / renormalizer.to_f
       end
       final_probs
     end
 
+    # called internally after yaml import to reset Hash defaults
+    def reset_after_import
+      data.reset_after_import
+    end
+
+    def self.from_yml(yml_data)
+      nbayes = YAML.load(yml_data)
+      nbayes.reset_after_import()  # yaml does not properly set the defaults on the Hashes
+      nbayes
+    end
+
     # Loads class instance from a data file (e.g., yaml)
     def self.from(yml_file)
-      nbayes = YAML.load_file(yml_file)
-      nbayes.reset_after_import()         		# yaml does not properly set the defaults on the Hashes
-      nbayes
+      File.open(yml_file, "rb") do |file|
+        self.from_yml(file.read)
+      end
     end
 
     # Load class instance
     def load(yml)
       if yml.nil?
-	return NBayes::Base.new
+        nbayes = NBayes::Base.new
       elsif yml[0..2] == "---"
-        nbayes = YAML.load(yml)
+        nbayes = self.class.from_yml(yml)
       else
-        nbayes = YAML.load_file(yml_file)
+        nbayes = self.class.from(yml)
       end
-      nbayes.reset_after_import()         		# yaml does not properly set the defaults on the Hashes
       nbayes
     end
-    
+
     # Dumps class instance to a data file (e.g., yaml) or a string
     def dump(arg)
       if arg.instance_of? String
@@ -190,14 +347,11 @@ module NBayes
 
   end
 
-
   module Result
+    # Return the key having the largest value
     def max_class
-      keys.max{|a,b| self[a] <=> self[b] }
+      keys.max{ |a,b| self[a] <=> self[b] }
     end
   end
 
 end
-
-
-

data/nbayes.gemspec

@@ -2,27 +2,28 @@
 # DO NOT EDIT THIS FILE DIRECTLY
 # Instead, edit Jeweler::Tasks in Rakefile, and run 'rake gemspec'
 # -*- encoding: utf-8 -*-
+# stub: nbayes 0.1.3 ruby lib
 
 Gem::Specification.new do |s|
-  s.name = "nbayes"
-  s.version = "0.1.1"
+  s.name = "nbayes".freeze
+  s.version = "0.1.3"
 
-  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
-  s.authors = ["oasic"]
-  s.date = "2012-07-13"
-  s.description = "Ruby implementation of Naive Bayes that generates true probabilities per class, works with many token types, and provides lots of bells and whistles while being optimized for performance."
-  s.email = "j@oasic.net"
+  s.required_rubygems_version = Gem::Requirement.new(">= 0".freeze) if s.respond_to? :required_rubygems_version=
+  s.require_paths = ["lib".freeze]
+  s.authors = ["oasic".freeze]
+  s.date = "2020-06-26"
+  s.description = "Ruby implementation of Naive Bayes that generates true probabilities per class, works with many token types, and provides lots of bells and whistles while being optimized for performance.".freeze
+  s.email = "j@oasic.net".freeze
   s.extra_rdoc_files = [
     "LICENSE.txt",
-    "README.rdoc"
+    "README.md"
   ]
   s.files = [
     ".document",
     ".rspec",
     "Gemfile",
-    "Gemfile.lock",
     "LICENSE.txt",
-    "README.rdoc",
+    "README.md",
     "Rakefile",
     "VERSION",
     "lib/nbayes.rb",
@@ -30,31 +31,30 @@ Gem::Specification.new do |s|
     "spec/nbayes_spec.rb",
     "spec/spec_helper.rb"
   ]
-  s.homepage = "http://github.com/oasic/nbayes"
-  s.licenses = ["MIT"]
-  s.require_paths = ["lib"]
-  s.rubygems_version = "1.8.15"
-  s.summary = "Full-featured Ruby implementation of Naive Bayes classifier"
+  s.homepage = "http://github.com/oasic/nbayes".freeze
+  s.licenses = ["MIT".freeze]
+  s.rubygems_version = "2.6.14".freeze
+  s.summary = "Full-featured Ruby implementation of Naive Bayes classifier".freeze
 
   if s.respond_to? :specification_version then
-    s.specification_version = 3
+    s.specification_version = 4
 
     if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
-      s.add_development_dependency(%q<rspec>, [">= 2.8.0"])
-      s.add_development_dependency(%q<rdoc>, [">= 3.12"])
-      s.add_development_dependency(%q<bundler>, [">= 1.0.0"])
-      s.add_development_dependency(%q<jeweler>, [">= 1.8.3"])
+      s.add_development_dependency(%q<rspec>.freeze, [">= 3.9.0"])
+      s.add_development_dependency(%q<rdoc>.freeze, [">= 3.0.0"])
+      s.add_development_dependency(%q<bundler>.freeze, [">= 2.0.0"])
+      s.add_development_dependency(%q<jeweler>.freeze, [">= 2.3.0"])
     else
-      s.add_dependency(%q<rspec>, [">= 2.8.0"])
-      s.add_dependency(%q<rdoc>, [">= 3.12"])
-      s.add_dependency(%q<bundler>, [">= 1.0.0"])
-      s.add_dependency(%q<jeweler>, [">= 1.8.3"])
+      s.add_dependency(%q<rspec>.freeze, [">= 3.9.0"])
+      s.add_dependency(%q<rdoc>.freeze, [">= 3.0.0"])
+      s.add_dependency(%q<bundler>.freeze, [">= 2.0.0"])
+      s.add_dependency(%q<jeweler>.freeze, [">= 2.3.0"])
     end
   else
-    s.add_dependency(%q<rspec>, [">= 2.8.0"])
-    s.add_dependency(%q<rdoc>, [">= 3.12"])
-    s.add_dependency(%q<bundler>, [">= 1.0.0"])
-    s.add_dependency(%q<jeweler>, [">= 1.8.3"])
+    s.add_dependency(%q<rspec>.freeze, [">= 3.9.0"])
+    s.add_dependency(%q<rdoc>.freeze, [">= 3.0.0"])
+    s.add_dependency(%q<bundler>.freeze, [">= 2.0.0"])
+    s.add_dependency(%q<jeweler>.freeze, [">= 2.3.0"])
   end
 end
 

data/spec/nbayes_spec.rb

@@ -1,161 +1,243 @@
 require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
 require 'fileutils'
 
-describe "NBayes" do
-  before do
-    @nbayes = NBayes::Base.new
-  end
-
-  it "should assign equal probability to each class" do
-    @nbayes.train( %w[a b c d e f g], 'classA' ) 
-    @nbayes.train( %w[a b c d e f g], 'classB' ) 
-    results = @nbayes.classify( %w[a b c] )
-    results['classA'].should == 0.5
-    results['classB'].should == 0.5
-  end
-
-  it "should handle more than 2 classes" do
-    @nbayes.train( %w[a a a a], 'classA' ) 
-    @nbayes.train( %w[b b b b], 'classB' ) 
-    @nbayes.train( %w[c c], 'classC' ) 
-    results = @nbayes.classify( %w[a a a a b c] )
-    results.max_class.should == 'classA'
-    results['classA'].should >= 0.4
-    results['classB'].should <= 0.3
-    results['classC'].should <= 0.3
-  end
-
-  it "should use smoothing by default to eliminate errors w/division by zero" do
-    @nbayes.train( %w[a a a a], 'classA' ) 
-    @nbayes.train( %w[b b b b], 'classB' ) 
-    results = @nbayes.classify( %w[x y z] )
-    results['classA'].should >= 0.0
-    results['classB'].should >= 0.0
-  end
-
-  it "should optionally purge low frequency data" do
-    100.times do
-      @nbayes.train( %w[a a a a], 'classA' ) 
-      @nbayes.train( %w[b b b b], 'classB' ) 
+describe NBayes do
+  let(:nbayes) { NBayes::Base.new }
+
+  describe 'should assign equal probability to each class' do
+    let(:results) { nbayes.classify(%w(a b c)) }
+
+    before do
+      nbayes.train(%w(a b c d e f g), 'classA')
+      nbayes.train(%w(a b c d e f g), 'classB')
+    end
+
+    specify { expect(results['classA']).to eq(0.5) }
+    specify { expect(results['classB']).to eq(0.5) }
+  end
+
+  describe 'should handle more than 2 classes' do
+    let(:results) { nbayes.classify(%w(a a a a b c)) }
+
+    before do
+      nbayes.train(%w(a a a a), 'classA')
+      nbayes.train(%w(b b b b), 'classB')
+      nbayes.train(%w(c c), 'classC')
+    end
+
+    specify { expect(results.max_class).to eq('classA') }
+    specify { expect(results['classA']).to be >= 0.4 }
+    specify { expect(results['classB']).to be <= 0.3 }
+    specify { expect(results['classC']).to be <= 0.3 }
+  end
+
+  describe 'should use smoothing by default to eliminate errors' do
+    context 'when dividing by zero' do
+      let(:results) { nbayes.classify(%w(x y z)) }
+
+      before do
+        nbayes.train(%w(a a a a), 'classA')
+        nbayes.train(%w(b b b b), 'classB')
+      end
+
+      specify { expect(results['classA']).to be >= 0.0 }
+      specify { expect(results['classB']).to be >= 0.0 }
+    end
+  end
+
+  describe 'should optionally purge low frequency data' do
+    let(:results) { nbayes.classify(%w(c)) }
+    let(:token_count) { nbayes.data.count_of_token_in_category('classB', 'c') }
+
+    before do
+      100.times do
+        nbayes.train(%w(a a a a), 'classA')
+        nbayes.train(%w(b b b b), 'classB')
+      end
+      nbayes.train(%w(a), 'classA')
+      nbayes.train(%w(c b), 'classB')
+    end
+
+    context 'before purge' do
+      specify { expect(results.max_class).to eq('classB') }
+      specify { expect(results['classB']).to be > 0.5 }
+      specify { expect(token_count).to eq(1) }
+    end
+
+    context 'after purge' do
+      before { nbayes.purge_less_than(2) }
+
+      specify { expect(results['classA']).to eq(0.5) }
+      specify { expect(results['classB']).to eq(0.5) }
+      specify { expect(token_count).to be_zero }
+    end
+  end
+
+  it 'works on all tokens - not just strings' do
+    nbayes.train([1, 2, 3], 'low')
+    nbayes.train([5, 6, 7], 'high')
+    results = nbayes.classify([2])
+    expect(results.max_class).to eq('low')
+    results = nbayes.classify([6])
+    expect(results.max_class).to eq('high')
+  end
+
+  describe 'should optionally allow class distribution to be assumed uniform' do
+    context 'before uniform distribution' do
+      let(:before_results) { nbayes.classify(['a']) }
+
+      before do
+        nbayes.train(%w(a a a a b), 'classA')
+        nbayes.train(%w(a a a a), 'classA')
+        nbayes.train(%w(a a a a), 'classB')
+      end
+
+      specify { expect(before_results.max_class).to eq('classA') }
+      specify { expect(before_results['classA']).to be > 0.5 }
+
+      context 'and after uniform distribution assumption' do
+        let(:after_results) { nbayes.classify(['a']) }
+
+        before { nbayes.assume_uniform = true }
+
+        specify { expect(after_results.max_class).to eq('classB') }
+        specify { expect(after_results['classB']).to be > 0.5 }
+      end
     end
-    @nbayes.train( %w[a], 'classA' ) 
-    @nbayes.train( %w[c b], 'classB' ) 
-    results = @nbayes.classify( %w[c] )
-    results.max_class.should == 'classB' 
-    results['classB'].should > 0.5 
-    @nbayes.data['classB'][:tokens]['c'].should == 1
-
-    @nbayes.purge_less_than(2)			# this removes the entry for 'c' in 'classB' because it has freq of 1
-						# NOTE: this does not decrement the 'example' count
-    results = @nbayes.classify( %w[c] )
-    @nbayes.data['classB'][:tokens]['c'].should == 0
-    results['classA'].should == 0.5 
-    results['classB'].should == 0.5 
-  end
-
-  it "works on all tokens - not just strings" do
-    @nbayes.train( [1, 2, 3], 'low' ) 
-    @nbayes.train( [5, 6, 7], 'high' ) 
-    results = @nbayes.classify( [2] )
-    results.max_class.should == 'low'
-    results = @nbayes.classify( [6] )
-    results.max_class.should == 'high'
-  end
-
-  it "should optionally allow class distribution to be assumed uniform" do
-    # before uniform distribution
-    @nbayes.train( %w[a a a a b], 'classA' ) 
-    @nbayes.train( %w[a a a a], 'classA' ) 
-    @nbayes.train( %w[a a a a], 'classB' ) 
-    results = @nbayes.classify( ['a'] )
-    results.max_class.should == 'classA'
-    results['classA'].should > 0.5 
-    # after uniform distribution assumption
-    @nbayes.assume_uniform = true
-    results = @nbayes.classify( ['a'] )
-    results.max_class.should == 'classB'
-    results['classB'].should > 0.5 
-  end
-
-  it "should allow log of vocab size in smoothing" do
-     
   end
 
   # In binarized mode, the frequency count is set to 1 for each token in each instance
   # For text, this is "set of words" rather than "bag of words"
-  it "should allow binarized mode" do
+  it 'should allow binarized mode' do
     # w/o binarized mode, token repetition can skew the results
-    def train_it
-      @nbayes.train( %w[a a a a a a a a a a a], 'classA' ) 
-      @nbayes.train( %w[b b], 'classA' ) 
-      @nbayes.train( %w[a c], 'classB' ) 
-      @nbayes.train( %w[a c], 'classB' ) 
-      @nbayes.train( %w[a c], 'classB' ) 
-    end
-    train_it
-    results = @nbayes.classify( ['a'] )
-    results.max_class.should == 'classA'
-    results['classA'].should > 0.5 
+    # def train_it
+    nbayes.train(%w(a a a a a a a a a a a), 'classA')
+    nbayes.train(%w(b b), 'classA')
+    nbayes.train(%w(a c), 'classB')
+    nbayes.train(%w(a c), 'classB')
+    nbayes.train(%w(a c), 'classB')
+    # end
+    # train_it
+    results = nbayes.classify(['a'])
+    expect(results.max_class).to eq('classA')
+    expect(results['classA']).to be > 0.5
     # this does not happen in binarized mode
-    @nbayes = NBayes::Base.new(:binarized => true)
-    train_it
-    results = @nbayes.classify( ['a'] )
-    results.max_class.should == 'classB'
-    results['classB'].should > 0.5 
+    nbayes = NBayes::Base.new(binarized: true)
+    nbayes.train(%w(a a a a a a a a a a a), 'classA')
+    nbayes.train(%w(b b), 'classA')
+    nbayes.train(%w(a c), 'classB')
+    nbayes.train(%w(a c), 'classB')
+    nbayes.train(%w(a c), 'classB')
+    results = nbayes.classify(['a'])
+    expect(results.max_class).to eq('classB')
+    expect(results['classB']).to be > 0.5
   end
 
-  it "allows smoothing constant k to be set to any value" do
+  it 'allows smoothing constant k to be set to any value' do
     # increasing k increases smoothing
-    @nbayes.train( %w[a a a c], 'classA' ) 
-    @nbayes.train( %w[b b b d], 'classB' ) 
-    @nbayes.k.should == 1
-    results = @nbayes.classify( ['c'] )
+    nbayes.train(%w(a a a c), 'classA')
+    nbayes.train(%w(b b b d), 'classB')
+    expect(nbayes.k).to eq(1)
+    results = nbayes.classify(['c'])
     prob_k1 = results['classA']
-    @nbayes.k = 5 
-    results = @nbayes.classify( ['c'] )
+    nbayes.k = 5
+    results = nbayes.classify(['c'])
     prob_k5 = results['classA']
-    prob_k1.should > prob_k5 			# increasing smoothing constant dampens the effect of the rare token 'c'
+    expect(prob_k1).to be > prob_k5 # increasing smoothing constant dampens the effect of the rare token 'c'
   end
 
-  it "optionally allows using the log of vocab size during smoothing" do
-    10_000.times do 
-      @nbayes.train( [rand(100)], 'classA' ) 
-      @nbayes.train( %w[b b b d], 'classB' ) 
+  it 'optionally allows using the log of vocab size during smoothing' do
+    10_000.times do
+      nbayes.train([rand(100)], 'classA')
+      nbayes.train(%w(b b b d), 'classB')
     end
   end
 
-  describe "saving" do
+  describe 'saving' do
+    let(:tmp_dir) { File.join(File.dirname(__FILE__), 'tmp') }
+    let(:yml_file) { File.join(tmp_dir, 'test.yml') }
+
+    before { FileUtils.mkdir(tmp_dir) unless File.exist?(tmp_dir) }
+
+    after { FileUtils.rm(yml_file) if File.exist?(yml_file) }
+
+    it 'should save to yaml and load from yaml' do
+      nbayes.train(%w(a a a a), 'classA')
+      nbayes.train(%w(b b b b), 'classB')
+      results = nbayes.classify(['b'])
+      expect(results['classB']).to be >= 0.5
+      nbayes.dump(yml_file)
+      expect(File.exist?(yml_file)).to eq(true)
+      nbayes2 = NBayes::Base.from(yml_file)
+      results = nbayes.classify(['b'])
+      expect(results['classB']).to be >= 0.5
+    end
+  end
+
+  it 'should dump to yaml string and load from yaml string' do
+    nbayes.train(%w(a a a a), 'classA')
+    nbayes.train(%w(b b b b), 'classB')
+    results = nbayes.classify(['b'])
+    expect(results['classB']).to be >= 0.5
+    yml = nbayes.dump(nbayes)
+    nbayes2 = NBayes::Base.new.load(yml)
+    results = nbayes.classify(['b'])
+    expect(results['classB']).to be >= 0.5
+  end
+
+  describe 'should delete a category' do
     before do
-      @tmp_dir = File.join( File.dirname(__FILE__), 'tmp')
-      FileUtils.mkdir(@tmp_dir)  if !File.exists?(@tmp_dir)
-      @yml_file = File.join(@tmp_dir, 'test.yml')
+      nbayes.train(%w(a a a a), 'classA')
+      nbayes.train(%w(b b b b), 'classB')
+      expect(nbayes.data.categories).to eq(%w(classA classB))
+      expect(nbayes.delete_category('classB')).to eq(['classA'])
     end
 
-    after do
-      FileUtils.rm(@yml_file)  if File.exists?(@yml_file)
+    specify { expect(nbayes.data.categories).to eq(['classA']) }
+  end
+
+  describe 'should do nothing if asked to delete an inexistant category' do
+    before { nbayes.train(%w(a a a a), 'classA') }
+
+    specify { expect(nbayes.data.categories).to eq(['classA']) }
+    specify { expect(nbayes.delete_category('classB')).to eq(['classA']) }
+    specify { expect(nbayes.data.categories).to eq(['classA']) }
+  end
+
+  describe 'should untrain a class' do
+    let(:results) { nbayes.classify(%w(a b c)) }
+
+    before do
+      nbayes.train(%w(a b c d e f g), 'classA')
+      nbayes.train(%w(a b c d e f g), 'classB')
+      nbayes.train(%w(a b c d e f g), 'classB')
+      nbayes.untrain(%w(a b c d e f g), 'classB')
     end
 
-    it "should save to yaml and load from yaml" do
-      @nbayes.train( %w[a a a a], 'classA' ) 
-      @nbayes.train( %w[b b b b], 'classB' ) 
-      results = @nbayes.classify( ['b'] )
-      results['classB'].should >= 0.5
-      @nbayes.dump(@yml_file)
-      File.exists?(@yml_file).should == true
-      @nbayes2 = NBayes::Base.from(@yml_file)
-      results = @nbayes.classify( ['b'] )
-      results['classB'].should >= 0.5
+    specify { expect(results['classA']).to eq(0.5) }
+    specify { expect(results['classB']).to eq(0.5) }
+  end
+
+  describe 'should remove the category when the only example is untrained' do
+    before do
+      nbayes.train(%w(a b c d e f g), 'classA')
+      nbayes.untrain(%w(a b c d e f g), 'classA')
     end
+
+    specify { expect(nbayes.data.categories).to eq([]) }
   end
 
-  it "should dump to yaml string and load from yaml string" do
-    @nbayes.train( %w[a a a a], 'classA' ) 
-    @nbayes.train( %w[b b b b], 'classB' ) 
-    results = @nbayes.classify( ['b'] )
-    results['classB'].should >= 0.5
-    yml = @nbayes.dump(@nbayes)
-    @nbayes2 = NBayes::Base.new.load(yml)
-    results = @nbayes.classify( ['b'] )
-    results['classB'].should >= 0.5
+  describe 'try untraining a non-existant category' do
+    let(:results) { nbayes.classify(%w(a b c)) }
+
+    before do
+      nbayes.train(%w(a b c d e f g), 'classA')
+      nbayes.train(%w(a b c d e f g), 'classB')
+      nbayes.untrain(%w(a b c d e f g), 'classC')
+    end
+
+    specify { expect(nbayes.data.categories).to eq(%w(classA classB)) }
+    specify { expect(results['classA']).to eq(0.5) }
+    specify { expect(results['classB']).to eq(0.5) }
   end
 end

metadata

@@ -1,77 +1,86 @@
---- !ruby/object:Gem::Specification 
+--- !ruby/object:Gem::Specification
 name: nbayes
-version: !ruby/object:Gem::Version 
-  prerelease: 
-  version: 0.1.1
+version: !ruby/object:Gem::Version
+  version: 0.1.3
 platform: ruby
-authors: 
+authors:
 - oasic
 autorequire: 
 bindir: bin
 cert_chain: []
-
-date: 2012-07-13 00:00:00 Z
-dependencies: 
-- !ruby/object:Gem::Dependency 
+date: 2020-06-26 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
   name: rspec
-  requirement: &id001 !ruby/object:Gem::Requirement 
-    none: false
-    requirements: 
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
     - - ">="
-      - !ruby/object:Gem::Version 
-        version: 2.8.0
+      - !ruby/object:Gem::Version
+        version: 3.9.0
   type: :development
   prerelease: false
-  version_requirements: *id001
-- !ruby/object:Gem::Dependency 
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.9.0
+- !ruby/object:Gem::Dependency
   name: rdoc
-  requirement: &id002 !ruby/object:Gem::Requirement 
-    none: false
-    requirements: 
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
     - - ">="
-      - !ruby/object:Gem::Version 
-        version: "3.12"
+      - !ruby/object:Gem::Version
+        version: 3.0.0
   type: :development
   prerelease: false
-  version_requirements: *id002
-- !ruby/object:Gem::Dependency 
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.0.0
+- !ruby/object:Gem::Dependency
   name: bundler
-  requirement: &id003 !ruby/object:Gem::Requirement 
-    none: false
-    requirements: 
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
     - - ">="
-      - !ruby/object:Gem::Version 
-        version: 1.0.0
+      - !ruby/object:Gem::Version
+        version: 2.0.0
   type: :development
   prerelease: false
-  version_requirements: *id003
-- !ruby/object:Gem::Dependency 
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.0.0
+- !ruby/object:Gem::Dependency
   name: jeweler
-  requirement: &id004 !ruby/object:Gem::Requirement 
-    none: false
-    requirements: 
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
     - - ">="
-      - !ruby/object:Gem::Version 
-        version: 1.8.3
+      - !ruby/object:Gem::Version
+        version: 2.3.0
   type: :development
   prerelease: false
-  version_requirements: *id004
-description: Ruby implementation of Naive Bayes that generates true probabilities per class, works with many token types, and provides lots of bells and whistles while being optimized for performance.
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.3.0
+description: Ruby implementation of Naive Bayes that generates true probabilities
+  per class, works with many token types, and provides lots of bells and whistles
+  while being optimized for performance.
 email: j@oasic.net
 executables: []
-
 extensions: []
-
-extra_rdoc_files: 
+extra_rdoc_files:
 - LICENSE.txt
-- README.rdoc
-files: 
-- .document
-- .rspec
+- README.md
+files:
+- ".document"
+- ".rspec"
 - Gemfile
-- Gemfile.lock
 - LICENSE.txt
-- README.rdoc
+- README.md
 - Rakefile
 - VERSION
 - lib/nbayes.rb
@@ -79,34 +88,27 @@ files:
 - spec/nbayes_spec.rb
 - spec/spec_helper.rb
 homepage: http://github.com/oasic/nbayes
-licenses: 
+licenses:
 - MIT
+metadata: {}
 post_install_message: 
 rdoc_options: []
-
-require_paths: 
+require_paths:
 - lib
-required_ruby_version: !ruby/object:Gem::Requirement 
-  none: false
-  requirements: 
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
   - - ">="
-    - !ruby/object:Gem::Version 
-      hash: 1596303061917544948
-      segments: 
-      - 0
-      version: "0"
-required_rubygems_version: !ruby/object:Gem::Requirement 
-  none: false
-  requirements: 
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
   - - ">="
-    - !ruby/object:Gem::Version 
-      version: "0"
+    - !ruby/object:Gem::Version
+      version: '0'
 requirements: []
-
 rubyforge_project: 
-rubygems_version: 1.8.15
+rubygems_version: 2.6.14
 signing_key: 
-specification_version: 3
+specification_version: 4
 summary: Full-featured Ruby implementation of Naive Bayes classifier
 test_files: []
-

data/Gemfile.lock

@@ -1,37 +0,0 @@
-GEM
-  remote: http://rubygems.org/
-  specs:
-    diff-lcs (1.1.3)
-    git (1.2.5)
-    jeweler (1.8.3)
-      bundler (~> 1.0)
-      git (>= 1.2.5)
-      rake
-      rdoc
-    json (1.7.3)
-    multi_json (1.3.6)
-    rake (0.9.2.2)
-    rdoc (3.12)
-      json (~> 1.4)
-    rspec (2.10.0)
-      rspec-core (~> 2.10.0)
-      rspec-expectations (~> 2.10.0)
-      rspec-mocks (~> 2.10.0)
-    rspec-core (2.10.1)
-    rspec-expectations (2.10.0)
-      diff-lcs (~> 1.1.3)
-    rspec-mocks (2.10.1)
-    simplecov (0.6.4)
-      multi_json (~> 1.0)
-      simplecov-html (~> 0.5.3)
-    simplecov-html (0.5.3)
-
-PLATFORMS
-  ruby
-
-DEPENDENCIES
-  bundler (>= 1.0.0)
-  jeweler (>= 1.8.3)
-  rdoc (>= 3.12)
-  rspec (>= 2.8.0)
-  simplecov