nb_class 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: f32812e7a50cf5358cdb78a9b64842c0f7070420
+  data.tar.gz: 3bec851e5fb7b279a4ca67fdc912c9b338d8ce05
+SHA512:
+  metadata.gz: 9ee190c6e18d28634f7f5e16501af078f941bcdb8d868adb642dd6408d79743db495ba30ce4375ddcaa6e344135fb65fb226860e2fb97ca12682c00eeee6c8f6
+  data.tar.gz: 93c4819682deada7c6e8953188ec10d29906b9e932f0a12b484320a859d4ae4a8e8543194e706cd1e6a98f8272549a0344b3212a2a6c1e252f29440405eb4c7a

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/Gemfile

@@ -0,0 +1,5 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in naive_bayes.gemspec
+gemspec
+

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 Humberto C Marchezi
+
+MIT License
+
+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.md

@@ -0,0 +1,50 @@
+# NBClass
+
+This gem provides a naive bayes classifier for models with N features.
+Simply put given examples of pre-defined categories the classifier learns how
+to classify new unknown examples.
+
+## Usage
+
+Classifier can be used in three steps:
+
+1. Provide category names and its respective training set
+
+2. Train classifier with provided categories
+
+3. Classify models
+
+For instance the example below shows how to classify words in categories test_a and test_b.
+Taking in consideration the number of occurrences of each word in both categories besides
+the frequency of the category the classifier returns the most probable category for the
+given collection of features.
+
+```ruby
+require 'nb_class/classifier'
+
+# 1 - Providing examples
+classifier = NBClass::Classifier.new
+classifier.not_spam << "Hi Joe, how are you?"
+classifier.spam << "Buy products you don't need"
+
+# 2 - Train classifier
+classifier.train
+
+# 3 - Classify new examples
+classifier.classify("Hi James, are you going?") # => not_spam
+classifier.classify("Buy not needed product") # => spam
+```
+
+## Planed Future Features
+
+1. Load category examples from external files to reduce code size
+2. Load pre-trained data from file to decrease classifier initialization time
+3. Optimize algorithms to use pre-calculated values
+
+## Contributing
+
+1. Fork it
+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 new Pull Request

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/lib/nb_class/classifier.rb

@@ -0,0 +1,140 @@
+require 'nb_class/error/category_name_already_exists'
+require 'nb_class/error/invalid_category_name'
+require 'nb_class/phrase_array'
+require 'nb_class/utils'
+
+module NBClass
+  class Classifier
+    SMALL_PROBABILITY = 0.000001
+
+    def initialize
+      @category_examples = {}
+      @occurrences = {}
+      @global_occurrences = {}
+      @probabilities = {}
+      @global_probabilities = {}
+      @category_occurrences = {}
+      @total_elements = 0
+      @total_phrases = 0;
+    end
+
+    def categories
+      @category_examples.keys
+    end
+
+    def train
+      @category_examples.keys.each do |category|
+        @category_examples[category].each do |phrase|
+          phrase.each do |word|
+            count_element_occurrence_in_category(category,word)
+            count_element_occurrence_in_global(word)
+            @total_elements += 1
+          end
+          count_category_occurrence(category)
+          @total_phrases += 1
+        end
+      end
+    end
+
+    def classify(elements)
+      elements = Utils.break_phrase_in_word_array(elements)
+      max_category = nil
+      max_probability = 0.0
+      @occurrences.keys.each do |key|
+        probability = category_probability_given_elements(category: key,elements: elements)
+        if probability > max_probability
+          max_probability = probability
+          max_category = key
+        end
+      end
+      max_category
+    end
+
+    def element_occurrence(params)
+      category = params[:category]
+      element = params[:element]
+      if category
+        @occurrences[category][element]
+      else
+        @global_occurrences[element]
+      end
+    end
+
+    def element_probability_given_category(params)
+      category = params[:category]
+      element  = params[:element]
+      element_occurrence_in_category = @occurrences[category][element]
+      total_elements_in_category = @occurrences[category].map{ |item| item[1] }.inject{ |sum, item| sum + item }
+      unless element_occurrence_in_category.nil?
+        element_occurrence_in_category.to_f / total_elements_in_category.to_f
+      else
+        SMALL_PROBABILITY
+      end
+    end
+
+    def element_probability(element)
+      element_occurrence = @global_occurrences[element]
+      unless element_occurrence.nil?
+        element_occurrence.to_f / @total_elements
+      else
+        SMALL_PROBABILITY
+      end
+    end
+
+    def category_probability(category)
+      @category_occurrences[category].to_f / @total_phrases.to_f
+    end
+
+    def category_probability_given_elements(params)
+      category = params[:category]
+      elements = params[:elements]
+      probability = 1.0
+      elements.each do |element|
+        element_probability_given_category = element_probability_given_category(category: category, element: element)
+        element_global_probability = element_probability(element)
+        element_probability = element_probability_given_category / element_global_probability
+        probability *= element_probability
+      end
+      category_probability = category_probability(category)
+      probability *= category_probability
+      probability
+    end
+
+    def method_missing(name, *args, &block)
+      @category_examples[name] = PhraseArray.new
+      define_singleton_method name do
+        @category_examples[name]
+      end
+      public_send(name)
+    end
+
+    private
+
+    def count_element_occurrence_in_category(category, element)
+      unless @occurrences.has_key?(category)
+        @occurrences[category] = {}
+      end
+      if !@occurrences[category].has_key?(element)
+        @occurrences[category][element] = 1
+      else
+        @occurrences[category][element] += 1
+      end
+    end
+
+    def count_element_occurrence_in_global(element)
+      unless @global_occurrences.has_key?(element)
+        @global_occurrences[element] = 1
+      else
+        @global_occurrences[element] += 1
+      end
+    end
+
+    def count_category_occurrence(category)
+      if @category_occurrences[category].nil?
+        @category_occurrences[category] = 1
+      else
+        @category_occurrences[category] += 1
+      end
+    end
+  end
+end

data/lib/nb_class/error/category_name_already_exists.rb

@@ -0,0 +1,7 @@
+module NBClass
+  module Error
+    class CategoryNameAlreadyExists < StandardError
+    end
+  end
+end
+

data/lib/nb_class/error/invalid_category_name.rb

@@ -0,0 +1,6 @@
+module NBClass
+  module Error
+    class InvalidCategoryName < StandardError
+    end
+  end
+end

data/lib/nb_class/phrase_array.rb

@@ -0,0 +1,24 @@
+require 'nb_class/utils'
+
+module NBClass
+  class PhraseArray
+    def initialize
+      @phrase_array = []
+    end
+    def <<(phrase)
+      @phrase_array << Utils.break_phrase_in_word_array(phrase)
+    end
+    def size
+      @phrase_array.size
+    end
+    def [](index)
+      @phrase_array[index]
+    end
+    def each(&block)
+      @phrase_array.each(&block)
+    end
+    def to_s
+      @phrase_array.to_s
+    end
+  end
+end

data/lib/nb_class/utils.rb

@@ -0,0 +1,10 @@
+module NBClass
+  class Utils
+    def self.break_phrase_in_word_array(phrase)
+      [",", ":", "?", "!", ";", ".", "/", "|"].each do |elem|
+        phrase = phrase.gsub(elem,"")
+      end
+      phrase.split
+    end
+  end
+end

data/lib/nb_class/version.rb

@@ -0,0 +1,3 @@
+module NBClass
+  VERSION = '0.0.1'
+end

data/lib/nb_class.rb

@@ -0,0 +1,4 @@
+require 'nb_class/classifier'
+require 'nb_class/version'
+require 'nb_class/error/category_name_already_exists'
+require 'nb_class/error/invalid_category_name'

data/nb_class.gemspec

@@ -0,0 +1,25 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'nb_class/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "nb_class"
+  spec.version       = NBClass::VERSION
+  spec.authors       = ["Humberto Marchezi"]
+  spec.email         = ["hcmarchezi@gmail.com"]
+  spec.description   = "Machine learning text classifier"
+  spec.summary       = "This gem offers a simplified interface to allow a text classifier to be trained by previous samples to identify different groups implemented with naïve bayes algorithm"
+  spec.homepage      = "https://rubygems.org/gems/nb_class"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/)
+  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.3"
+  spec.add_development_dependency "rake", '~> 0'
+  spec.add_development_dependency "rspec", '~> 0'
+  spec.add_development_dependency "debugger", '~> 0'
+end

data/spec/nb_class/classifier_spec.rb

@@ -0,0 +1,108 @@
+require 'spec_helper'
+require 'nb_class/classifier'
+
+describe NBClass::Classifier do
+  context 'categories examples' do
+    it 'should be added as a dynamically created method' do
+      classifier = NBClass::Classifier.new
+      classifier.random_categ << "example 1"
+      classifier.random_categ << "example 2"
+      classifier.random_categ << "example 3"
+      expect(classifier.random_categ.size).to be_eql(3)
+    end
+    it 'should break a phrase into an array of words' do
+      classifier = NBClass::Classifier.new
+      classifier.another_categ << "word1 word2 word3"
+      expect(classifier.another_categ[0]).to be_eql(["word1","word2","word3"])
+    end
+  end
+
+  context 'element occurrence count' do
+    it 'should count elements occurrence in a category' do
+      classifier = NBClass::Classifier.new
+      classifier.test  << 'car tree street truck car'
+      classifier.train
+      expect(classifier.element_occurrence(category: :test, element: 'car')).to be_eql(2)
+      expect(classifier.element_occurrence(category: :test, element: 'tree')).to be_eql(1)
+      expect(classifier.element_occurrence(category: :test, element: 'street')).to be_eql(1)
+      expect(classifier.element_occurrence(category: :test, element: 'truck')).to be_eql(1)
+    end
+
+    it 'should globally count elements occurrence' do
+      classifier = NBClass::Classifier.new
+      classifier.test_a << 'blue green blue'
+      classifier.test_b << 'black black black blue'
+      classifier.train
+      expect(classifier.element_occurrence(element: 'blue')).to be_eql(3)
+      expect(classifier.element_occurrence(element: 'green')).to be_eql(1)
+      expect(classifier.element_occurrence(element: 'black')).to be_eql(3)
+    end
+  end
+
+  context 'probability calculation' do
+    let(:classifier) { NBClass::Classifier.new }
+    before do
+      classifier.test_a << 'blue green blue'
+      classifier.test_b << 'black black black blue'
+      classifier.train
+    end
+
+    it 'should calculate the probability of an element occurrence given the category' do
+      expect(classifier.element_probability_given_category(category: :test_a, element: 'blue')).to be_eql(2.0 / 3.0)
+      expect(classifier.element_probability_given_category(category: :test_a, element: 'black')).to be_eql(0.000001)
+      expect(classifier.element_probability_given_category(category: :test_a, element: 'green')).to be_eql(1.0 / 3.0)
+      expect(classifier.element_probability_given_category(category: :test_a, element: 'gray')).to be_eql(0.000001)
+    end
+
+    it 'should calculate the probability of an element occurrence (global context)' do
+      expect(classifier.element_probability('blue')).to be_eql(3.0 / 7.0)
+      expect(classifier.element_probability('black')).to be_eql(3.0 / 7.0)
+      expect(classifier.element_probability('green')).to be_eql(1.0 / 7.0)
+      expect(classifier.element_probability('gray')).to be_eql(0.000001)
+    end
+
+    it 'should calculate the probability of the category' do
+      expect(classifier.category_probability(:test_a)).to be_eql(1.0 / 2.0)
+      expect(classifier.category_probability(:test_b)).to be_eql(1.0 / 2.0)
+    end
+  end
+
+  #####################################
+  # P(blue) = 5/10 = 0.5
+  # P(green) = 5/10 = 0.5
+  #####################################
+  # P(blue|A) = 1/5 = 0.2
+  # P(green|A) = 4/5 = 0.8
+  #####################################
+  # P(green|B) = 1/5 = 0.2
+  # P(green|A) = 4/5 = 0.8
+  #####################################
+  # P(A|blue) = 0.5 * ( 0.2/0.5 ) = 0.5 * 0.4 = 0.2
+  # P(A|blue,blue,green) = 0.5 * ( 0.2/0.5 * 0.2/0.5 * 0.8/0.5 ) = 0.128
+  # P(A|blue,green,green) = 0.5 * ( 0.8/0.5 * 0.8/0.5 * 0.2/0.5 ) = 0.512
+  # P(A|green,green,green) = 0.5 * ( 0.8/0.5 * 0.8/0.5 * 0.8/0.5 ) = 2.048
+  #####################################
+  context 'classification' do
+    let(:classifier) { NBClass::Classifier.new }
+
+    before do
+      classifier.test_a << 'green green green green blue'
+      classifier.test_b << 'blue blue blue blue green'
+      classifier.train
+    end
+
+    it 'should calculate the probability of an element array to belong to a category' do
+      expect(classifier.category_probability_given_elements(category: :test_a, elements: ['blue'])).to eq(0.2)
+      expect(classifier.category_probability_given_elements(category: :test_a, elements: ['blue', 'blue',  'green'])).to eq(0.12800000000000003)
+      expect(classifier.category_probability_given_elements(category: :test_a, elements: ['blue', 'green', 'green'])).to eq(0.5120000000000001)
+      expect(classifier.category_probability_given_elements(category: :test_a, elements: ['green', 'green',  'green'])).to eq(2.0480000000000005)
+    end
+
+    it 'should return the most probable category for an element array' do
+      expect(classifier.classify('blue')).to eq(:test_b)
+      expect(classifier.classify('blue blue green')).to eq(:test_b)
+      expect(classifier.classify('blue green green')).to eq(:test_a)
+      expect(classifier.classify('green green green')).to eq(:test_a)
+    end
+  end
+end

data/spec/nb_class/phrase_array_spec.rb

@@ -0,0 +1,47 @@
+require 'spec_helper'
+require 'nb_class/phrase_array'
+
+describe NBClass::PhraseArray do
+  context 'phrase inclusion' do
+    it 'should be done with operator <<' do
+      phrase_array = NBClass::PhraseArray.new
+      phrase_array << "this is statement 1"
+      phrase_array << "this is statement 2"
+      phrase_array << "this is statement 3"
+      expect(phrase_array.size).to be_eql(3)
+    end
+    it 'should break included phrase as an array of words' do
+      phrase_array = NBClass::PhraseArray.new
+      phrase_array << "this is another phrase"
+      expect(phrase_array.size).to be_eql(1)
+      expect(phrase_array[0].size).to be_eql(4)
+      expect(phrase_array[0][0]).to be_eql('this')
+      expect(phrase_array[0][1]).to be_eql('is')
+      expect(phrase_array[0][2]).to be_eql('another')
+      expect(phrase_array[0][3]).to be_eql('phrase')
+    end
+  end
+  context 'phrase and word access' do
+    it 'should allow to interate through each phrase and word' do
+      phrase_array = NBClass::PhraseArray.new
+      phrase_array << "statement 1"
+      phrase_array << "statement 2"
+      phrase_array << "statement 3"
+      expected_values = [
+        ["statement", "1"],
+        ["statement", "2"],
+        ["statement", "3"]
+      ]
+      i = 0
+      j = 0
+      phrase_array.each do |phrase|
+        phrase.each do |word|
+          expect(word).to be_eql(expected_values[i][j])
+          j = j + 1
+        end
+        j = 0;
+        i = i + 1
+      end
+    end
+  end
+end

data/spec/nb_class/utils_spec.rb

@@ -0,0 +1,13 @@
+require 'spec_helper'
+require 'nb_class/utils'
+
+describe NBClass::Utils do
+  context 'string break in words' do
+    it 'should be brokwn in array of words and remove punctuation marks' do
+      phrase = "word1, word2? word3! word4: word5; word6. word7 word8/ word9|"
+      expected_array = ["word1", "word2", "word3", "word4", "word5", "word6", "word7", "word8", "word9"]
+      actual_array = NBClass::Utils.break_phrase_in_word_array(phrase)
+      expect(actual_array).to be_eql(expected_array)
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,3 @@
+RSpec.configure do |config|
+
+end

metadata

@@ -0,0 +1,122 @@
+--- !ruby/object:Gem::Specification
+name: nb_class
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Humberto Marchezi
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-10-15 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: debugger
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Machine learning text classifier
+email:
+- hcmarchezi@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/nb_class.rb
+- lib/nb_class/classifier.rb
+- lib/nb_class/error/category_name_already_exists.rb
+- lib/nb_class/error/invalid_category_name.rb
+- lib/nb_class/phrase_array.rb
+- lib/nb_class/utils.rb
+- lib/nb_class/version.rb
+- nb_class.gemspec
+- spec/nb_class/classifier_spec.rb
+- spec/nb_class/phrase_array_spec.rb
+- spec/nb_class/utils_spec.rb
+- spec/spec_helper.rb
+homepage: https://rubygems.org/gems/nb_class
+licenses:
+- MIT
+metadata: {}
+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: []
+rubyforge_project: 
+rubygems_version: 2.4.8
+signing_key: 
+specification_version: 4
+summary: This gem offers a simplified interface to allow a text classifier to be trained
+  by previous samples to identify different groups implemented with naïve bayes algorithm
+test_files:
+- spec/nb_class/classifier_spec.rb
+- spec/nb_class/phrase_array_spec.rb
+- spec/nb_class/utils_spec.rb
+- spec/spec_helper.rb