classifier-reborn 2.1.0 → 2.2.0

data/lib/classifier-reborn/category_namer.rb

@@ -2,7 +2,6 @@
 # Copyright:: Copyright (c) 2005 Lucas Carlson
 # License::   LGPL
 
-require 'fast_stemmer'
 require 'classifier-reborn/extensions/hasher'
 
 module ClassifierReborn

data/lib/classifier-reborn/extensions/hasher.rb

@@ -21,7 +21,7 @@ module ClassifierReborn
 
     # Return a word hash without extra punctuation or short symbols, just stemmed words
     def clean_word_hash(str, language = 'en', enable_stemmer = true)
-      word_hash_for_words str.gsub(/[^\p{WORD}\s]/, '').downcase.split, language, enable_stemmer
+      word_hash_for_words(str.gsub(/[^\p{WORD}\s]/, '').downcase.split, language, enable_stemmer)
     end
 
     def word_hash_for_words(words, language = 'en', enable_stemmer = true)

data/lib/classifier-reborn/lsi.rb

@@ -86,7 +86,7 @@ module ClassifierReborn
       add_item(item)
     end
 
-    # Returns the categories for a given indexed items. You are free to add and remove
+    # Returns categories for a given indexed item. You are free to add and remove
     # items from this as you see fit. It does not invalide an index to change its categories.
     def categories_for(item)
       return [] unless @items[item]
@@ -300,6 +300,10 @@ module ClassifierReborn
       top_n.collect { |x| @word_list.word_for_index(content_vector_array.index(x)) }
     end
 
+    def reset
+      initialize(auto_rebuild: @auto_rebuild, cache_node_vectors: @cache_node_vectors)
+    end
+
     private
 
     def build_reduced_matrix(matrix, cutoff = 0.75)

data/lib/classifier-reborn/lsi/word_list.rb

@@ -13,14 +13,12 @@ module ClassifierReborn
 
     # Adds a word (if it is new) and assigns it a unique dimension.
     def add_word(word)
-      term = word
-      @location_table[term] = @location_table.size unless @location_table[term]
+      @location_table[word] = @location_table.size unless @location_table[word]
     end
 
     # Returns the dimension of the word or nil if the word is not in the space.
     def [](lookup)
-      term = lookup
-      @location_table[term]
+      @location_table[lookup]
     end
 
     def word_for_index(ind)

data/lib/classifier-reborn/validators/classifier_validator.rb

@@ -0,0 +1,169 @@
+module ClassifierReborn
+  module ClassifierValidator
+
+    module_function
+
+    def cross_validate(classifier, sample_data, fold=10, *options)
+      classifier = ClassifierReborn::const_get(classifier).new(options) if classifier.is_a?(String)
+      sample_data.shuffle!
+      partition_size = sample_data.length / fold
+      partitioned_data = sample_data.each_slice(partition_size)
+      conf_mats = []
+      fold.times do |i|
+        training_data = partitioned_data.take(fold)
+        test_data = training_data.slice!(i)
+        conf_mats << validate(classifier, training_data.flatten!(1), test_data)
+      end
+      classifier.reset()
+      generate_report(conf_mats)
+    end
+
+    def validate(classifier, training_data, test_data, *options)
+      classifier = ClassifierReborn::const_get(classifier).new(options) if classifier.is_a?(String)
+      classifier.reset()
+      training_data.each do |rec|
+        classifier.train(rec.first, rec.last)
+      end
+      evaluate(classifier, test_data)
+    end
+
+    def evaluate(classifier, test_data)
+      conf_mat = empty_conf_mat(classifier.categories.sort)
+      test_data.each do |rec|
+        actual = rec.first.tr('_', ' ').capitalize
+        predicted = classifier.classify(rec.last)
+        conf_mat[actual][predicted] += 1 unless predicted.nil?
+      end
+      conf_mat
+    end
+
+    def generate_report(*conf_mats)
+      conf_mats.flatten!
+      accumulated_conf_mat = conf_mats.length == 1 ? conf_mats.first : empty_conf_mat(conf_mats.first.keys.sort)
+      header = "Run     Total   Correct Incorrect  Accuracy"
+      puts
+      puts " Run Report ".center(header.length, "-")
+      puts header
+      puts "-" * header.length
+      if conf_mats.length > 1
+        conf_mats.each_with_index do |conf_mat, i|
+          run_report = build_run_report(conf_mat)
+          print_run_report(run_report, i+1)
+          conf_mat.each do |actual, cols|
+            cols.each do |predicted, v|
+              accumulated_conf_mat[actual][predicted] += v
+            end
+          end
+        end
+        puts "-" * header.length
+      end
+      run_report = build_run_report(accumulated_conf_mat)
+      print_run_report(run_report, "All")
+      puts
+      print_conf_mat(accumulated_conf_mat)
+      puts
+      conf_tab = conf_mat_to_tab(accumulated_conf_mat)
+      print_conf_tab(conf_tab)
+    end
+
+    def build_run_report(conf_mat)
+      correct = incorrect = 0
+      conf_mat.each do |actual, cols|
+        cols.each do |predicted, v|
+          if actual == predicted
+            correct += v
+          else
+            incorrect += v
+          end
+        end
+      end
+      total = correct + incorrect
+      {total: total, correct: correct, incorrect: incorrect, accuracy: divide(correct, total)}
+    end
+
+    def conf_mat_to_tab(conf_mat)
+      conf_tab = Hash.new {|h, k| h[k] = {p: {t: 0, f: 0}, n: {t: 0, f: 0}}}
+      conf_mat.each_key do |positive|
+        conf_mat.each do |actual, cols|
+          cols.each do |predicted, v|
+            conf_tab[positive][positive == predicted ? :p : :n][actual == predicted ? :t : :f] += v
+          end
+        end
+      end
+      conf_tab
+    end
+
+    def print_run_report(stats, prefix="", print_header=false)
+      puts "#{"Run".rjust([3, prefix.length].max)}     Total   Correct Incorrect  Accuracy" if print_header
+      puts "#{prefix.to_s.rjust(3)} #{stats[:total].to_s.rjust(9)} #{stats[:correct].to_s.rjust(9)} #{stats[:incorrect].to_s.rjust(9)} #{stats[:accuracy].round(5).to_s.ljust(7, '0').rjust(9)}"
+    end
+
+    def print_conf_mat(conf_mat)
+      header = ["Predicted ->"] + conf_mat.keys + ["Total", "Recall"]
+      cell_size = header.map(&:length).max
+      header = header.map{|h| h.rjust(cell_size)}.join(" ")
+      puts " Confusion Matrix ".center(header.length, "-")
+      puts header
+      puts "-" * header.length
+      predicted_totals = conf_mat.keys.map{|predicted| [predicted, 0]}.to_h
+      correct = 0
+      conf_mat.each do |k, rec|
+        actual_total = rec.values.reduce(:+)
+        puts ([k.ljust(cell_size)] + rec.values.map{|v| v.to_s.rjust(cell_size)} + [actual_total.to_s.rjust(cell_size), divide(rec[k], actual_total).round(5).to_s.rjust(cell_size)]).join(" ")
+        rec.each do |cat, val|
+          predicted_totals[cat] += val
+          correct += val if cat == k
+        end
+      end
+      total = predicted_totals.values.reduce(:+)
+      puts "-" * header.length
+      puts (["Total".ljust(cell_size)] + predicted_totals.values.map{|v| v.to_s.rjust(cell_size)} + [total.to_s.rjust(cell_size), "".rjust(cell_size)]).join(" ")
+      puts (["Precision".ljust(cell_size)] + predicted_totals.keys.map{|k| divide(conf_mat[k][k], predicted_totals[k]).round(5).to_s.rjust(cell_size)} + ["Accuracy ->".rjust(cell_size), divide(correct, total).round(5).to_s.rjust(cell_size)]).join(" ")
+    end
+
+    def print_conf_tab(conf_tab)
+      conf_tab.each do |positive, tab|
+        puts "# Positive class: #{positive}"
+        derivations = conf_tab_derivations(tab)
+        print_derivations(derivations)
+        puts
+      end
+    end
+
+    def conf_tab_derivations(tab)
+      positives = tab[:p][:t] + tab[:n][:f]
+      negatives = tab[:n][:t] + tab[:p][:f]
+      total     = positives + negatives
+      {
+        total_population:   positives + negatives,
+        condition_positive: positives,
+        condition_negative: negatives,
+        true_positive:      tab[:p][:t],
+        true_negative:      tab[:n][:t],
+        false_positive:     tab[:p][:f],
+        false_negative:     tab[:n][:f],
+        prevalence:         divide(positives, total),
+        specificity:        divide(tab[:n][:t], negatives),
+        recall:             divide(tab[:p][:t], positives),
+        precision:          divide(tab[:p][:t], tab[:p][:t] + tab[:p][:f]),
+        accuracy:           divide(tab[:p][:t] + tab[:n][:t], total),
+        f1_score:           divide(2 * tab[:p][:t], 2 * tab[:p][:t] + tab[:p][:f] + tab[:n][:f])
+      }
+    end
+
+    def print_derivations(derivations)
+      max_len = derivations.keys.map(&:length).max
+      derivations.each do |k, v|
+        puts k.to_s.tr('_', ' ').capitalize.ljust(max_len) + " : " + v.to_s
+      end
+    end
+
+    def empty_conf_mat(categories)
+      categories.map{|actual| [actual, categories.map{|predicted| [predicted, 0]}.to_h]}.to_h
+    end
+
+    def divide(dividend, divisor)
+      divisor.zero? ? 0.0 : dividend / divisor.to_f
+    end
+  end
+end

data/lib/classifier-reborn/version.rb

@@ -1,3 +1,3 @@
 module ClassifierReborn
-  VERSION = '2.1.0'
+  VERSION = '2.2.0'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: classifier-reborn
 version: !ruby/object:Gem::Version
-  version: 2.1.0
+  version: 2.2.0
 platform: ruby
 authors:
 - Lucas Carlson
@@ -10,7 +10,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-01-01 00:00:00.000000000 Z
+date: 2017-12-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: fast-stemmer
@@ -110,14 +110,26 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: redis
+  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: 
 email:
 - lucas@rufy.com
 - parkrmoore@gmail.com
 - chase.gilliam@gmail.com
-executables:
-- bayes.rb
-- summarize.rb
+executables: []
 extensions: []
 extra_rdoc_files:
 - README.markdown
@@ -125,8 +137,8 @@ extra_rdoc_files:
 files:
 - LICENSE
 - README.markdown
-- bin/bayes.rb
-- bin/summarize.rb
+- data/stopwords/ar
+- data/stopwords/bn
 - data/stopwords/ca
 - data/stopwords/cs
 - data/stopwords/da
@@ -135,15 +147,23 @@ files:
 - data/stopwords/es
 - data/stopwords/fi
 - data/stopwords/fr
+- data/stopwords/hi
 - data/stopwords/hu
 - data/stopwords/it
+- data/stopwords/ja
 - data/stopwords/nl
 - data/stopwords/no
 - data/stopwords/pl
 - data/stopwords/pt
+- data/stopwords/ru
 - data/stopwords/se
 - data/stopwords/tr
+- data/stopwords/vi
+- data/stopwords/zh
 - lib/classifier-reborn.rb
+- lib/classifier-reborn/backends/bayes_memory_backend.rb
+- lib/classifier-reborn/backends/bayes_redis_backend.rb
+- lib/classifier-reborn/backends/no_redis_error.rb
 - lib/classifier-reborn/bayes.rb
 - lib/classifier-reborn/category_namer.rb
 - lib/classifier-reborn/extensions/hasher.rb
@@ -154,6 +174,7 @@ files:
 - lib/classifier-reborn/lsi/content_node.rb
 - lib/classifier-reborn/lsi/summarizer.rb
 - lib/classifier-reborn/lsi/word_list.rb
+- lib/classifier-reborn/validators/classifier_validator.rb
 - lib/classifier-reborn/version.rb
 homepage: https://github.com/jekyll/classifier-reborn
 licenses:
@@ -176,8 +197,9 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.5.2
+rubygems_version: 2.6.14
 signing_key: 
 specification_version: 2
 summary: A general classifier module to allow Bayesian and other types of classifications.
 test_files: []
+has_rdoc: true

data/bin/bayes.rb

@@ -1,36 +0,0 @@
-#!/usr/bin/env ruby
-
-begin
-  require 'rubygems'
-  require 'classifier'
-rescue
-  require 'classifier'
-end
-
-require 'madeleine'
-
-m = SnapshotMadeleine.new(File.expand_path('~/.bayes_data')) do
-  ClassifierReborn::Bayes.new 'Interesting', 'Uninteresting'
-end
-
-case ARGV[0]
-when 'add'
-  case ARGV[1].downcase
-  when 'interesting'
-    m.system.train_interesting File.open(ARGV[2]).read
-    puts "#{ARGV[2]} has been classified as interesting"
-  when 'uninteresting'
-    m.system.train_uninteresting File.open(ARGV[2]).read
-    puts "#{ARGV[2]} has been classified as uninteresting"
-  else
-    puts 'Invalid category: choose between interesting and uninteresting'
-    exit(1)
-  end
-when 'classify'
-  puts m.system.classify(File.open(ARGV[1]).read)
-else
-  puts 'Invalid option: choose add [category] [file] or clasify [file]'
-  exit(-1)
-end
-
-m.take_snapshot

data/bin/summarize.rb

@@ -1,16 +0,0 @@
-#!/usr/bin/env ruby
-
-begin
-  require 'rubygems'
-  require 'classifier'
-rescue
-  require 'classifier'
-end
-
-require 'open-uri'
-
-num = ARGV[1].to_i
-num = num < 1 ? 10 : num
-
-text = open(ARGV.first).read
-puts text.gsub(/<[^>]+>/, '').gsub(/[\s]+/, ' ').summary(num)