nbayes 0.1.0

data/.document

@@ -0,0 +1,5 @@
+lib/**/*.rb
+bin/*
+- 
+features/**/*.feature
+LICENSE.txt

data/.rspec

@@ -0,0 +1 @@
+--color

data/Gemfile

@@ -0,0 +1,14 @@
+source "http://rubygems.org"
+# Add dependencies required to use your gem here.
+# Example:
+#   gem "activesupport", ">= 2.3.5"
+
+# 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"
+end
+gem 'simplecov', :require => false, :group => :test

data/Gemfile.lock

@@ -0,0 +1,37 @@
+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

data/LICENSE.txt

@@ -0,0 +1,20 @@
+Copyright (c) 2012 Oasic Technologies LLC
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.rdoc

@@ -0,0 +1,31 @@
+== nbayes
+
+_gem install nbayes_
+
+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
+* outputs probabilities, instead of just class w/max probability
+* customizable constant value for Laplacian smoothing
+* optional and customizable purging of low-frequency tokens (for performance)
+* optional binarized mode
+* uses log probabilities to avoid underflow
+
+For more information, view this blog post (coming soon)
+
+== 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.
+* Fork the project.
+* Start a feature/bugfix branch.
+* Commit and push until you are happy with your contribution.
+* 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
+
+Copyright (c) 2012 Oasic Technologies LLC. See LICENSE.txt for
+further details.
+

data/Rakefile

@@ -0,0 +1,49 @@
+# encoding: utf-8
+
+require 'rubygems'
+require 'bundler'
+begin
+  Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
+end
+require 'rake'
+
+require 'jeweler'
+Jeweler::Tasks.new do |gem|
+  # gem is a Gem::Specification... see http://docs.rubygems.org/read/chapter/20 for more options
+  gem.name = "nbayes"
+  gem.homepage = "http://github.com/oasic/nbayes"
+  gem.license = "MIT"
+  gem.summary = %Q{Full-featured Ruby implementation of Naive Bayes classifier}
+  gem.description = %Q{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.}
+  gem.email = "j@oasic.net"
+  gem.authors = ["oasic"]
+  # dependencies defined in Gemfile
+end
+Jeweler::RubygemsDotOrgTasks.new
+
+require 'rspec/core'
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new(:spec) do |spec|
+  spec.pattern = FileList['spec/**/*_spec.rb']
+end
+
+RSpec::Core::RakeTask.new(:rcov) do |spec|
+  spec.pattern = 'spec/**/*_spec.rb'
+  spec.rcov = true
+end
+
+task :default => :spec
+
+require 'rdoc/task'
+Rake::RDocTask.new do |rdoc|
+  version = File.exist?('VERSION') ? File.read('VERSION') : ""
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "nbayes #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/VERSION

@@ -0,0 +1 @@
+0.1.0

data/lib/nbayes.rb

@@ -0,0 +1,187 @@
+require 'yaml'
+
+# == NBayes::Base
+#
+# Robust implementation of NaiveBayes:
+# - using log probabilities to avoid floating point issues
+# - Laplacian smoothing for unseen tokens
+# - 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
+
+    attr_accessor :assume_uniform, :debug, :k, :vocab, :data, :log_vocab
+    attr_reader :binarized
+
+    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)
+      @data = Hash.new
+      @data.default_proc = get_default_proc()
+      #@data = {
+      #  "category1": {
+      #    "tokens": Hash.new(0),
+      #    "total_tokens": 0,
+      #    "examples": 0
+      #  },
+      # ...
+      #}
+    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
+    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
+      end  # each vocab word
+      remove_list.keys.each {|token| @vocab.delete(token) }
+      #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
+    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 }
+    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
+      end
+    end
+
+    def classify(tokens)
+      print "classify: #{tokens.join(', ')}\n" if @debug
+      probs = {}
+      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
+    end
+
+    # Calculates the actual probability of a class given the tokens
+    # (this is the work horse of the code)
+    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
+      end
+      # 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 }
+      # One more caveat:
+      # We're using log probabilities, so the numbers are negative and the smallest negative number is actually the largest prob.
+      # To convert, we need to maintain the relative distance between all of the probabilities:
+      # - divide log prob by normalizer: this keeps ratios the same, but reverses the ordering
+      # - re-normalize based off new counts
+      # - final calculation
+      # Ex: -1,-1,-2  =>  -4/-1, -4/-1, -4/-2
+      #   - renormalize and calculate => 4/10, 4/10, 2/10
+      intermed = {}
+      renormalizer = 0
+      prob_numerator.each do |cat, numerator|
+	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
+      end
+      final_probs
+    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
+    end
+
+    # Dumps class instance to a file
+    def dump(yml_file)
+      File.open(yml_file, "w") {|f| YAML.dump(self, f) }
+    end
+
+  end
+
+
+  module Result
+    def max_class
+      keys.max{|a,b| self[a] <=> self[b] }
+    end
+  end
+
+end
+
+
+

data/nbayes.gemspec

@@ -0,0 +1,60 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run 'rake gemspec'
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = "nbayes"
+  s.version = "0.1.0"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["oasic"]
+  s.date = "2012-06-27"
+  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.extra_rdoc_files = [
+    "LICENSE.txt",
+    "README.rdoc"
+  ]
+  s.files = [
+    ".document",
+    ".rspec",
+    "Gemfile",
+    "Gemfile.lock",
+    "LICENSE.txt",
+    "README.rdoc",
+    "Rakefile",
+    "VERSION",
+    "lib/nbayes.rb",
+    "nbayes.gemspec",
+    "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"
+
+  if s.respond_to? :specification_version then
+    s.specification_version = 3
+
+    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"])
+    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"])
+    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"])
+  end
+end
+

data/spec/nbayes_spec.rb

@@ -0,0 +1,151 @@
+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' ) 
+    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
+    # 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 
+    # 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 
+  end
+
+  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'] )
+    prob_k1 = results['classA']
+    @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'
+  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' ) 
+    end
+  end
+
+  describe "saving" 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')
+    end
+
+    after do
+      FileUtils.rm(@yml_file)  if File.exists?(@yml_file)
+    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
+    end
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,16 @@
+# These 2 lines MUST be first
+require 'simplecov'
+SimpleCov.start
+
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+require 'rspec'
+require 'nbayes'
+
+# Requires supporting files with custom matchers and macros, etc,
+# in ./support/ and its subdirectories.
+Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].each {|f| require f}
+
+RSpec.configure do |config|
+  
+end

metadata

@@ -0,0 +1,112 @@
+--- !ruby/object:Gem::Specification 
+name: nbayes
+version: !ruby/object:Gem::Version 
+  prerelease: 
+  version: 0.1.0
+platform: ruby
+authors: 
+- oasic
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2012-06-27 00:00:00 Z
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 2.8.0
+  type: :development
+  prerelease: false
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: rdoc
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "3.12"
+  type: :development
+  prerelease: false
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: bundler
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 1.0.0
+  type: :development
+  prerelease: false
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  name: jeweler
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 1.8.3
+  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.
+email: j@oasic.net
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- LICENSE.txt
+- README.rdoc
+files: 
+- .document
+- .rspec
+- Gemfile
+- Gemfile.lock
+- LICENSE.txt
+- README.rdoc
+- Rakefile
+- VERSION
+- lib/nbayes.rb
+- nbayes.gemspec
+- spec/nbayes_spec.rb
+- spec/spec_helper.rb
+homepage: http://github.com/oasic/nbayes
+licenses: 
+- MIT
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: -4266862066196834109
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.8.15
+signing_key: 
+specification_version: 3
+summary: Full-featured Ruby implementation of Naive Bayes classifier
+test_files: []
+