classyfier 0.1.0

data/.gitignore

@@ -0,0 +1,3 @@
+pkg/*
+*.gem
+.bundle

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in classyfier.gemspec
+gemspec

data/Rakefile

@@ -0,0 +1,2 @@
+require 'bundler'
+Bundler::GemHelper.install_tasks

data/classyfier.gemspec

@@ -0,0 +1,21 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "classyfier/version"
+
+Gem::Specification.new do |s|
+  s.name        = "classyfier"
+  s.version     = Classyfier::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Josh Cutler"]
+  s.email       = ["josh@codepresencelabs.com"]
+  s.homepage    = ""
+  s.summary     = %q{Simple Naive Bayesian Classifier}
+  s.description = %q{Simple Naive Bayesian Classifier}
+
+  s.rubyforge_project = "classyfier"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+end

data/lib/classyfier.rb

@@ -0,0 +1,2 @@
+require 'classyfier/version'
+require 'classyfier/naive_bayes'

data/lib/classyfier/naive_bayes.rb

@@ -0,0 +1,108 @@
+module Classyfier
+  module NaiveBayes
+    class NaiveBayesClassifier
+      attr_reader :data_size
+      attr_reader :attribute_counts, :category_counts
+      
+      def initialize(opts = {})
+        @data_size = 0
+        @attribute_counts = {}
+        @category_counts = {}
+        
+        @laplacean_smoother = opts[:laplacean_smoother] || 0
+        @precision = opts[:precision] ? Float(opts[:precision]**10) : 100000.0
+      end
+      
+      def train(data_hash, category)
+        @data_size += 1
+        @category_counts[category] ||= 0
+        @category_counts[category] += 1
+        
+        _learn(data_hash, category)
+      end
+      
+      def classify(data_hash)
+        category_scores = _category_scores(data_hash)
+        max = [:none, 0]
+        category_scores.each_pair do |key, value|
+          max = [key, value] if value > max[1]
+        end
+        return max
+      end
+      
+      def category_scores(data_hash)
+        category_scores = _category_scores(data_hash)
+      end
+      
+      private
+        def _category_scores(data_hash, name='', odds={})
+          data_hash.each_pair do |key, value|
+            case value
+            when String
+              value.split(" ").each do |sub_string|
+                _calculate_conditional(key, sub_string, name, odds) unless sub_string.strip.empty?
+              end
+            else
+              _calculate_conditional(key, value, name, odds)
+            end
+          end
+          
+          #calculate posteriors given data
+          posteriors = {}
+          odds.keys.each do |category|
+            likelihood = 1
+            odds[category].each_pair{|key, value| likelihood *= value}
+            
+            prior = (@category_counts[category] + @laplacean_smoother) / (Float(@data_size) + @laplacean_smoother*@category_counts.keys.size)
+            
+            marginal = 0
+            odds.keys.each do |category2|
+              likelihood2 = 1
+              odds[category2].each_pair do |key, value| 
+                likelihood2 *= value
+              end
+              marginal +=  likelihood2 * ((@category_counts[category2] + @laplacean_smoother) / (Float(@data_size) + @laplacean_smoother*@category_counts.keys.size))
+            end
+            
+            begin
+              posteriors[category] = ((likelihood * prior / marginal)*@precision).round / @precision
+            rescue
+              posteriors[category] = 0
+            end
+          end
+          
+          return posteriors
+        end
+        
+        def _calculate_conditional(key, value, name, odds)
+          @attribute_counts.each_pair do |category, raw_counts|
+            cat = odds[category] ||= {}
+            keys = raw_counts["#{name}_#{key}"] || {}
+            total_values = 0
+            keys.keys.each {|k| total_values += keys[k]}
+            cat["#{name}_#{key}_#{value}"] = Float((keys[value] || 0) + @laplacean_smoother) / (total_values + @laplacean_smoother*keys.keys.length)
+          end
+        end
+      
+        def _learn(data_hash, category, name='')
+          data_hash.each_pair do |key, value|
+            case value
+            when String
+              value.split(" ").each do |sub_string|
+                _store_learned_attribute(key, sub_string, category, name) unless sub_string.strip.empty?
+              end
+            else
+              _store_learned_attribute(key, value, category, name)
+            end
+          end
+        end
+        
+        def _store_learned_attribute(key, value, category, name)
+          cat = (@attribute_counts[category] ||= {})
+          values = (cat["#{name}_#{key}"] ||= {})
+          values[value] ||= 0
+          values[value] += 1
+        end
+    end
+  end
+end

data/lib/classyfier/version.rb

@@ -0,0 +1,3 @@
+module Classyfier
+  VERSION = "0.1.0"
+end

data/test/helper.rb

@@ -0,0 +1,10 @@
+require 'rubygems'
+require 'test/unit'
+require 'shoulda'
+
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+require 'classyfier'
+
+class Test::Unit::TestCase
+end

data/test/test_classyfier.rb

@@ -0,0 +1,80 @@
+require 'helper'
+
+class TestClassyfier < Test::Unit::TestCase
+  
+  context "after training on a few items with no smoothing" do
+    setup do
+      @classyfier = Classyfier::NaiveBayes::NaiveBayesClassifier.new
+      @classyfier.train({:name => "derp", :extension => "dta"}, :data)
+      @classyfier.train({:name => "malerp", :extension => "dta"}, :data)
+      @classyfier.train({:name => "hi", :extension => "dta"}, :data)
+      @classyfier.train({:name => "derp malerp", :extension => "pdf"}, :not_data)
+      @classyfier.train({:name => "foo bar", :extension => "dta"}, :not_data)
+    end
+    
+    should "have stored the priors" do
+      assert_equal 3, @classyfier.attribute_counts[:data]['_extension']['dta']
+      assert_equal(5, @classyfier.data_size)
+      assert_equal(3, @classyfier.category_counts[:data])
+      assert_equal(2, @classyfier.category_counts[:not_data])
+    end
+    
+    context "and classifying an item" do
+      setup do
+        @scores = @classyfier.classify({:name => "derp hi", :extension => "dta"})
+        @scores1 = @classyfier.classify({:name => "malerp", :extension => "dta"})
+        @scores2 = @classyfier.classify({:extension => "pdf"})
+        @scores3 = @classyfier.classify({:extension => "unknown"})
+      end
+      
+      should "return the proper probability" do
+        # P(data|"derp hi") = P("derp hi"|data)*P(data) / P("derp hi") = P("derp hi"|data)*P(data) / P("derp hi"|data)P(data) + P("derp hi|not")P(not)  = 
+        # P("derp"|data)*P("hi"|data)P(dta|data)*P(data) / P("derp"|data)P(hi"|data)P(dta|data)P(data) + P("derp"|not)P("hi"|not)P(dta|data)P(not)
+        # (1/3)(1/3)(3/3)(3/5)/((1/3)(1/3)(3/3)(3/5) + (1/4)(0/4)(1/2)(2/5))
+        assert_equal([:data, 1], @scores)
+        # P("malerp"|data)P(dta|data)P(data)/P("malerp"|data)P(dta|data)P(data) + P("malerp"|not_data)P(dta|not_data)P(not_data)
+        # (.333*1*.6)/(.333*1*.6+.25*.5*.4)
+        assert_equal([:data, 0.8], @scores1)
+        assert_equal([:not_data, 1], @scores2)
+        assert_equal([:none, 0], @scores3)
+      end
+    end
+  end
+  
+  context "after training on a few items with smoothing" do
+    setup do
+      @classyfier = Classyfier::NaiveBayes::NaiveBayesClassifier.new(:laplacean_smoother => 1)
+      @classyfier.train({:name => "derp", :extension => "dta"}, :data)
+      @classyfier.train({:name => "malerp", :extension => "dta"}, :data)
+      @classyfier.train({:name => "derp malerp", :extension => "pdf"}, :not_data)
+      @classyfier.train({:name => "foo bar", :extension => "dta"}, :not_data)
+      @classyfier.train({:name => "hi", :extension => "dta"}, :data)
+    end
+    
+    should "have stored the priors" do
+      assert_equal 3, @classyfier.attribute_counts[:data]['_extension']['dta']
+      assert_equal(5, @classyfier.data_size)
+      assert_equal(3, @classyfier.category_counts[:data])
+      assert_equal(2, @classyfier.category_counts[:not_data])
+    end
+    
+    context "and classifying an item" do
+      setup do
+        @scores = @classyfier.classify({:name => "derp hi", :extension => "dta"})
+        @scores1 = @classyfier.classify({:name => "malerp", :extension => "dta"})
+        @scores2 = @classyfier.classify({:extension => "pdf"})
+        @scores3 = @classyfier.classify({:extension => "unknown"})
+      end
+      
+      should "return the proper probability" do
+        # P(data|"derp hi") = P("derp hi"|data)*P(data) / P("derp hi") = P("derp hi"|data)*P(data) / P("derp hi"|data)P(data) + P("derp hi|not")P(not)  = 
+        # P("derp"|data)*P("hi"|data)*P(dta|data)*P(data) / P("derp"|data)P(hi"|data)P(dta|data)P(data) + P("derp"|not)P("hi"|not)P(dta|not)P(not)
+        #((1+1)/(3+3))((1+1)/(3+3))((3+1)/(3+1))((3+1)/(5+2))/(((1+1)/(3+3))((1+1)/(3+3))((3+1)/(3+1))((3+1)/(5+2)) + ((1+1)/(4+4))((0+1)/(4+4))((1+1)/(2+2))((2+1)/(5+2)))
+        assert_equal([:data, 0.90459], @scores)
+        assert_equal([:data, 0.78049], @scores1)
+        assert_equal([:not_data, 0.6], @scores2)
+        assert_equal([:data, 0.57143], @scores3)
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,77 @@
+--- !ruby/object:Gem::Specification 
+name: classyfier
+version: !ruby/object:Gem::Version 
+  hash: 27
+  prerelease: false
+  segments: 
+  - 0
+  - 1
+  - 0
+  version: 0.1.0
+platform: ruby
+authors: 
+- Josh Cutler
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-11-09 00:00:00 -05:00
+default_executable: 
+dependencies: []
+
+description: Simple Naive Bayesian Classifier
+email: 
+- josh@codepresencelabs.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .gitignore
+- Gemfile
+- Rakefile
+- classyfier.gemspec
+- lib/classyfier.rb
+- lib/classyfier/naive_bayes.rb
+- lib/classyfier/version.rb
+- test/helper.rb
+- test/test_classyfier.rb
+has_rdoc: true
+homepage: ""
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: classyfier
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: Simple Naive Bayesian Classifier
+test_files: 
+- test/helper.rb
+- test/test_classyfier.rb