bae 0.0.1

data/README.md

@@ -0,0 +1,54 @@
+Bae
+===
+
+Bae is a multinomial naive bayes classifier based on another gem ["naivebayes"](https://github.com/id774/naivebayes), only this one uses java to do the heavy lifting.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'bae'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install bae
+
+## Usage
+
+You can refer to ["naivebayes"](https://github.com/id774/naivebayes) gem for more documentation, or the tests for examples. Here is a copy/ paster example:
+
+
+### You can provide a frequency hash to the trainer
+
+```ruby
+classifier = ::Bae::Classifier.new
+classifier.train("positive", {"aaa" => 0, "bbb" => 1})
+classifier.train("negative", {"ccc" => 2, "ddd" => 3})
+classifier.classify({"aaa" => 1, "bbb" => 1})
+
+#=> {"positive" => 0.8767123287671234, "negative" => 0.12328767123287669}
+```
+
+### Or you can train with strings
+```ruby
+classifier = ::Bae::Classifier.new
+classifier.train("positive", "aaa aaa bbb");
+classifier.train("negative", "ccc ccc ddd ddd");
+classifier.train("neutral", "eee eee eee fff fff fff");
+classifier.classify("aaa bbb")
+
+#=> {"positive"=>0.8962655601659751, "negative"=>0.0663900414937759, "neutral"=>0.037344398340248955}
+```
+
+
+## Contributing
+
+1. Fork it ( https://github.com/[my-github-username]/bae/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new Pull Request

data/Rakefile

@@ -0,0 +1,8 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+desc "Run specs"
+RSpec::Core::RakeTask.new(:spec)
+
+desc "Run specs (default)"
+task :default => :spec

data/bae.gemspec

@@ -0,0 +1,24 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'bae/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "bae"
+  spec.version       = Bae::VERSION
+  spec.authors       = ["Garrett Thornburg"]
+  spec.email         = ["film42@gmail.com"]
+  spec.summary       = "Multinomial naive bayes classifier with a kick of java"
+  spec.description   = "Multinomial naive bayes classifier with a kick of java"
+  spec.homepage      = "https://github.com/film42/bae"
+  spec.license       = "GPL version 3, or LGPL version 3 (Dual License)"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.6"
+  spec.add_development_dependency "rspec"
+  spec.add_development_dependency "rake"
+end

data/build.xml

@@ -0,0 +1,18 @@
+<project>
+
+    <target name="clean">
+        <delete dir="build"/>
+    </target>
+
+    <target name="compile">
+        <mkdir dir="out"/>
+        <mkdir dir="out/classes"/>
+        <javac srcdir="src/main/java" destdir="out/classes"/>
+    </target>
+
+    <target name="jar" depends="compile">
+        <mkdir dir="target"/>
+        <jar destfile="target/bae.jar" basedir="out/classes" excludes="**/*.jar,**/MANIFEST.MF,**/BCKEY.*" />
+    </target>
+
+</project>

data/lib/bae/classifier.rb

@@ -0,0 +1,19 @@
+module Bae
+  class Classifier
+
+    attr_reader :internal_classifier
+
+    def initialize
+      @internal_classifier = ::Java::Bae::NaiveBayesClassifier.new
+    end
+
+    def train(label, feature)
+      internal_classifier.train(label, ::Java::Bae::Document.new(feature))
+    end
+
+    def classify(feature)
+      internal_classifier.classify(::Java::Bae::Document.new(feature))
+    end
+
+  end
+end

data/lib/bae/version.rb

@@ -0,0 +1,3 @@
+module Bae
+  VERSION = "0.0.1"
+end

data/lib/bae.rb

@@ -0,0 +1,12 @@
+require "bae/version"
+
+require "target/bae.jar"
+
+java_import "bae.Document"
+java_import "bae.FrequencyTable"
+java_import "bae.NaiveBayesClassifier"
+
+require "bae/classifier"
+
+module Bae
+end

data/spec/lib/bae/classifier_spec.rb

@@ -0,0 +1,27 @@
+require 'spec_helper'
+
+describe ::Bae::Classifier do
+
+  subject { described_class.new }
+
+  it "can classify from ruby to java with a hash document" do
+    subject.train("positive", {"aaa" => 0, "bbb" => 1})
+    subject.train("negative", {"ccc" => 2, "ddd" => 3})
+    results = subject.classify({"aaa" => 1, "bbb" => 1})
+
+    expect(results["positive"]).to be_within(0.001).of(0.94117)
+    expect(results["negative"]).to be_within(0.001).of(0.05882)
+  end
+
+  it "can classify from ruby to java with a string based document" do
+    subject.train("positive", "aaa aaa bbb");
+    subject.train("negative", "ccc ccc ddd ddd");
+    subject.train("neutral", "eee eee eee fff fff fff");
+    results = subject.classify("aaa bbb")
+
+    expect(results["positive"]).to be_within(0.001).of(0.89626)
+    expect(results["negative"]).to be_within(0.001).of(0.06639)
+    expect(results["neutral"]).to be_within(0.001).of(0.03734)
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,8 @@
+require 'bundler/setup'
+require 'bae'
+require 'rspec'
+
+RSpec.configure do |c|
+  c.order = :rand
+  c.color = true
+end

data/src/main/java/bae/Document.java

@@ -0,0 +1,42 @@
+package bae;
+
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Scanner;
+
+public class Document {
+
+    private Map<String, Long> frequencyMap;
+
+    public Document(String text) {
+        createFrequencyMap(text);
+    }
+
+    public Document(Map<String, Long> frequencyMap) {
+        this.frequencyMap = frequencyMap;
+    }
+
+    public Map<String, Long> getFrequencyMap() {
+        return frequencyMap;
+    }
+
+    public void addZeroCount(String key) {
+        this.frequencyMap.put(key, 0L);
+    }
+
+    private void createFrequencyMap(String text) {
+        this.frequencyMap = new HashMap<>();
+
+        Scanner parser = new Scanner(text);
+        while(parser.hasNext()) {
+            String wordToken = parser.next();
+
+            // Set initial count if it doesn't have one yet
+            // Use zero because we'll add counts in the next line.
+            this.frequencyMap.putIfAbsent(wordToken, 0L);
+
+            // Update count
+            this.frequencyMap.put(wordToken, this.frequencyMap.get(wordToken) + 1);
+        }
+    }
+}

data/src/main/java/bae/FrequencyTable.java

@@ -0,0 +1,44 @@
+package bae;
+
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Set;
+
+public class FrequencyTable {
+
+    private Map<String, Map<String, Long>> frequencyTable;
+
+    public FrequencyTable() {
+        this.frequencyTable = new HashMap<>();
+    }
+
+    public void insertOrIgnore(String label) {
+        // Add new hash to frequency table if it's not already there
+        this.frequencyTable.putIfAbsent(label, new HashMap<String, Long>());
+    }
+
+    public void increaseFrequencyBy(String label, String word, long frequency) {
+        // Add label if it doesn't exist
+        insertOrIgnore(label);
+
+        Map<String, Long> frequencyRow = this.frequencyTable.get(label);
+
+        // Make sure we have a frequency for that position in the table
+        frequencyRow.putIfAbsent(word, 0L);
+
+        // Update frequency
+        frequencyRow.put(word, frequencyRow.get(word) + frequency);
+    }
+
+    public Set<String> getLabels() {
+        return this.frequencyTable.keySet();
+    }
+
+    public long get(String label, String word) {
+        try {
+            return this.frequencyTable.get(label).get(word);
+        } catch (NullPointerException e) {
+            return 0L;
+        }
+    }
+}

data/src/main/java/bae/NaiveBayesClassifier.java

@@ -0,0 +1,120 @@
+package bae;
+
+import java.util.HashMap;
+import java.util.Map;
+
+public class NaiveBayesClassifier {
+
+    private FrequencyTable frequencyTable;
+    private Map<String, Long> wordTable;
+    private Map<String, Long> instanceCountOf;
+    private double totalCount = 0;
+
+    public NaiveBayesClassifier() {
+        this.frequencyTable = new FrequencyTable();
+        this.wordTable = new HashMap<>();
+        this.instanceCountOf = new HashMap<>();
+    }
+
+    public void train(String label, Document document) {
+        // Add to the frequency table if it doesn't exist
+        this.frequencyTable.insertOrIgnore(label);
+
+        // Update frequency table with the documents frequency
+        for(Map.Entry<String, Long> entry : document.getFrequencyMap().entrySet()) {
+            String word = entry.getKey();
+            long frequency = entry.getValue();
+
+            // Update counts
+            this.frequencyTable.increaseFrequencyBy(label, word, frequency);
+            // Add the word's presence to the word table
+            this.wordTable.put(word, 1L);
+        }
+
+        // Update global counts
+        totalCount += 1;
+        // Update instance count
+        updateIntegerCountBy(this.instanceCountOf, label, 1);
+    }
+
+    public Map<String, Double> classify(Document document) {
+        Map<String, Double> classPriorOf = new HashMap<>();
+        Map<String, Double> likelihoodOf = new HashMap<>();
+        Map<String, Double> classPosteriorOf = new HashMap<>();
+        Map<String, Long> frequencyMap = document.getFrequencyMap();
+        double evidence = 0;
+
+        // Update the prior
+        for(Map.Entry<String, Long> entry : this.instanceCountOf.entrySet()) {
+            String label = entry.getKey();
+            double frequency = entry.getValue();
+
+            // Update instance count
+            classPriorOf.put(label, (frequency / this.totalCount));
+        }
+
+        // Update likelihood counts
+        for(String label : this.frequencyTable.getLabels()) {
+            // Set initial likelihood
+            likelihoodOf.put(label, 1d);
+
+            // Calculate likelihoods
+            for(String word : wordTable.keySet()) {
+                double laplaceWordLikelihood =
+                        (this.frequencyTable.get(label, word) + 1d) /
+                        (this.instanceCountOf.get(label) + this.wordTable.size());
+
+                // Update likelihood
+                double likelihood = likelihoodOf.get(label);
+                if(frequencyMap.containsKey(word)) {
+                    likelihoodOf.put(label, likelihood * laplaceWordLikelihood);
+                } else {
+                    likelihoodOf.put(label, likelihood * (1d - laplaceWordLikelihood));
+                }
+            }
+
+            // Default class posterior of label to 1.0
+            classPosteriorOf.putIfAbsent(label, 1d);
+
+            // Update class posterior
+            double classPosterior = classPriorOf.get(label) * likelihoodOf.get(label);
+            classPosteriorOf.put(label, classPosterior);
+            evidence += classPosterior;
+        }
+
+        // Normalize results
+        for(Map.Entry<String, Double> entry : classPosteriorOf.entrySet()) {
+            String label = entry.getKey();
+            double posterior = entry.getValue();
+            classPosteriorOf.put(label, posterior / evidence);
+        }
+
+        return classPosteriorOf;
+    }
+
+    public void updateIntegerCountBy(Map<String, Long> someMap, String someKey, long count) {
+        someMap.putIfAbsent(someKey, 0L);
+        someMap.put(someKey, someMap.get(someKey) + count);
+    }
+
+    public void updateDoubleCountBy(Map<String, Double> someMap, String someKey, double count) {
+        someMap.putIfAbsent(someKey, 0.0);
+        someMap.put(someKey, someMap.get(someKey) + count);
+    }
+
+    public FrequencyTable getFrequencyTable() {
+        return this.frequencyTable;
+    }
+
+    public Map<String, Long> getWordTable() {
+        return this.wordTable;
+    }
+
+    public Map<String, Long> getInstanceCount() {
+        return this.instanceCountOf;
+    }
+
+    public double getTotalCount() {
+        return totalCount;
+    }
+}

data/src/test/java/bae/DocumentTest.java

@@ -0,0 +1,34 @@
+package bae;
+
+import bae.Document;
+import org.junit.Test;
+
+import java.util.Map;
+
+import static org.junit.Assert.*;
+
+public class DocumentTest {
+
+    @Test
+    public void testCanCreateAccurateFrequencyTable() {
+        Document document = new Document("aaa bbb aaa bbb ccc");
+        Map<String, Long> frequencyMap = document.getFrequencyMap();
+
+        assertEquals(2, (long)frequencyMap.get("aaa"));
+        assertEquals(2, (long)frequencyMap.get("bbb"));
+        assertEquals(1, (long)frequencyMap.get("ccc"));
+    }
+
+    @Test
+    public void testCanParseADirtyString() {
+        Document document = new Document(" a    aaa\ta     \t\t\t  aa  a      bbb a  aaa   bbb   ccc    ");
+        Map<String, Long> frequencyMap = document.getFrequencyMap();
+
+        assertEquals(2, (long)frequencyMap.get("aaa"));
+        assertEquals(2, (long)frequencyMap.get("bbb"));
+        assertEquals(1, (long)frequencyMap.get("ccc"));
+        assertEquals(1, (long)frequencyMap.get("aa"));
+        assertEquals(4, (long)frequencyMap.get("a"));
+    }
+
+}

data/src/test/java/bae/FrequencyTableTest.java

@@ -0,0 +1,23 @@
+package bae;
+
+import bae.FrequencyTable;
+import org.junit.Test;
+
+import static org.junit.Assert.*;
+
+public class FrequencyTableTest {
+
+    @Test
+    public void canInsertIntoFrequencyTable() {
+        FrequencyTable frequencyTable = new FrequencyTable();
+
+        frequencyTable.increaseFrequencyBy("a", "b", 100);
+
+        assertEquals(100, frequencyTable.get("a", "b"));
+
+        // Make sure we fail correctly
+        assertEquals(0, frequencyTable.get("a", "z"));
+        assertEquals(0, frequencyTable.get("z", "z"));
+    }
+
+}

data/src/test/java/bae/NaiveBayesClassifierTest.java

@@ -0,0 +1,134 @@
+package bae;
+
+import bae.Document;
+import bae.NaiveBayesClassifier;
+import org.junit.Test;
+
+import java.util.Map;
+
+import static org.junit.Assert.*;
+
+public class NaiveBayesClassifierTest {
+
+    @Test
+    public void canCorrectlyTrainFrequencyTable() {
+        NaiveBayesClassifier n = new NaiveBayesClassifier();
+
+        n.train("positive", new Document("bbb"));
+        n.train("negative", new Document("ccc ccc ddd ddd ddd"));
+        n.train("positive", new Document("aaa bbb bbb"));
+        n.train("negative", new Document("ccc ccc ccc ddd ddd ddd ddd"));
+
+        assertEquals(1, n.getFrequencyTable().get("positive", "aaa"));
+        assertEquals(3, n.getFrequencyTable().get("positive", "bbb"));
+        assertEquals(5, n.getFrequencyTable().get("negative", "ccc"));
+        assertEquals(7, n.getFrequencyTable().get("negative", "ddd"));
+    }
+
+    @Test
+    public void canCorrectlyTrainWordTable() {
+        NaiveBayesClassifier n = new NaiveBayesClassifier();
+
+        n.train("positive", new Document("bbb"));
+        n.train("negative", new Document("ccc ccc ddd ddd ddd"));
+        n.train("positive", new Document("aaa bbb bbb"));
+        n.train("negative", new Document("ccc ccc ccc ddd ddd ddd ddd"));
+
+        assertEquals(1, (long)n.getWordTable().get("aaa"));
+        assertEquals(1, (long)n.getWordTable().get("bbb"));
+        assertEquals(1, (long)n.getWordTable().get("ccc"));
+        assertEquals(1, (long)n.getWordTable().get("ddd"));
+    }
+
+    @Test
+    public void canCorrectlyTrainInstanceCount() {
+        NaiveBayesClassifier n = new NaiveBayesClassifier();
+
+        n.train("positive", new Document("bbb"));
+        n.train("negative", new Document("ccc ccc ddd ddd ddd"));
+        n.train("positive", new Document("aaa bbb bbb"));
+        n.train("negative", new Document("ccc ccc ccc ddd ddd ddd ddd"));
+        n.train("negative", new Document("ccc ccc ccc ddd ddd"));
+
+        assertEquals(2, (long)n.getInstanceCount().get("positive"));
+        assertEquals(3, (long)n.getInstanceCount().get("negative"));
+        assertEquals(5, (long)n.getTotalCount());
+    }
+
+    @Test
+    public void canCorrectlyClassifyPositiveWithTwoLabels() {
+        NaiveBayesClassifier n = new NaiveBayesClassifier();
+
+        Document d = new Document("bbb");
+        d.addZeroCount("aaa");
+
+        n.train("positive", d);
+        n.train("negative", new Document("ccc ccc ddd ddd ddd"));
+
+        Map<String, Double> results = n.classify(new Document("aaa bbb"));
+
+        assertEquals(0.9411764705882353, results.get("positive"), 0.00001);
+        assertEquals(0.05882352941176469, results.get("negative"), 0.00001);
+    }
+
+    @Test
+    public void canCorrectlyClassifyNegativeWithTwoLabels() {
+        NaiveBayesClassifier n = new NaiveBayesClassifier();
+
+        Document d = new Document("bbb");
+        d.addZeroCount("aaa");
+
+        n.train("positive", d);
+        n.train("negative", new Document("ccc ccc ddd ddd ddd"));
+
+        Map<String, Double> results = n.classify(new Document("ccc ccc ccc ddd ddd ddd"));
+
+        assertEquals(0.05882352941176469, results.get("positive"), 0.00001);
+        assertEquals(0.9411764705882353, results.get("negative"), 0.00001);
+    }
+
+    @Test
+    public void canCorrectlyClassifyPositiveWithThreeLabels() {
+        NaiveBayesClassifier n = new NaiveBayesClassifier();
+
+        n.train("positive", new Document("aaa aaa bbb"));
+        n.train("negative", new Document("ccc ccc ddd ddd"));
+        n.train("neutral", new Document("eee eee eee fff fff fff"));
+
+        Map<String, Double> results = n.classify(new Document("aaa bbb"));
+
+        assertEquals(0.896265560165975, results.get("positive"), 0.00001);
+        assertEquals(0.06639004149377592, results.get("negative"), 0.00001);
+        assertEquals(0.03734439834024896, results.get("neutral"), 0.00001);
+    }
+
+    @Test
+    public void canCorrectlyClassifyNegativeWithThreeLabels() {
+        NaiveBayesClassifier n = new NaiveBayesClassifier();
+
+        n.train("positive", new Document("aaa aaa bbb"));
+        n.train("negative", new Document("ccc ccc ddd ddd"));
+        n.train("neutral", new Document("eee eee eee fff fff fff"));
+
+        Map<String, Double> results = n.classify(new Document("ccc ccc ccc ddd ddd"));
+
+        assertEquals(0.05665722379603399, results.get("positive"), 0.00001);
+        assertEquals(0.9178470254957508, results.get("negative"), 0.00001);
+        assertEquals(0.0254957507082153, results.get("neutral"), 0.00001);
+    }
+
+    @Test
+    public void canCorrectlyClassifyNeutralWithThreeLabels() {
+        NaiveBayesClassifier n = new NaiveBayesClassifier();
+
+        n.train("positive", new Document("aaa aaa bbb"));
+        n.train("negative", new Document("ccc ccc ddd ddd"));
+        n.train("neutral", new Document("eee eee eee fff fff fff"));
+
+        Map<String, Double> results = n.classify(new Document("aaa ddd ddd eee eee eee fff"));
+
+        assertEquals(0.12195121951219513, results.get("positive"), 0.00001);
+        assertEquals(0.09756097560975606, results.get("negative"), 0.00001);
+        assertEquals(0.7804878048780488, results.get("neutral"), 0.00001);
+    }
+}