danielsdeleo-basset 1.0.4

data/History.txt

@@ -0,0 +1,7 @@
+== 1.0.0 / 2008-01-08
+
+* Initial release
+
+== 1.0.1 / 2008-01-08
+
+* Updated release with new code actually checked into rubyforge.

data/License.txt

@@ -0,0 +1,20 @@
+Copyright (c) 2007 Paul Dix
+
+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/Manifest.txt

@@ -0,0 +1,21 @@
+History.txt
+License.txt
+Manifest.txt
+README.txt
+Rakefile
+lib/basset.rb
+lib/basset/classification_evaluator.rb
+lib/basset/core_extensions.rb
+lib/basset/document.rb
+lib/basset/document_override_example.rb
+lib/basset/feature.rb
+lib/basset/feature_extractor.rb
+lib/basset/feature_selector.rb
+lib/basset/naive_bayes.rb
+lib/basset/yaml_serialization.rb
+spec/spec.opts
+spec/spec_helper.rb
+spec/unit/document_spec.rb
+spec/unit/feature_extractor_spec.rb
+spec/unit/feature_selector_spec.rb
+spec/unit/feature_spec.rb

data/README.rdoc

@@ -0,0 +1,58 @@
+Author::    Paul Dix  (mailto:paul@pauldix.net)
+
+=Summary
+This is Daniel DeLeo's fork of Paul Dix's basset[http://github.com/pauldix/basset/], a library for machine learning.
+
+Basset includes a generic document representation class, a feature selector, a feature extractor, naive bayes  and SVM classifiers, and a classification evaluator for running tests. The goal is to create a general framework that is easy to modify for specific problems. It is designed to be extensible so it should be easy to add more classification and clustering algorithms.
+
+==Additions
+I have added lots of tests (TATFT![http://smartic.us/2008/8/15/tatft-i-feel-a-revolution-coming-on]), a document class for URIs, a high level classifier class, SVM support using libsvm-ruby-swig[http://github.com/tomz/libsvm-ruby-swig] and an anomaly detector (one-class classifier).  I have also modified the naive bayes classifier so that it does not require you to use the feature selector and extractor.  This should help you to get encouraging results when you first start.  Once you have a large training dataset, you can use the feature selector and extractor for better performance.
+
+=Usage
+The most popular task is spam identification, though there are many others, such as document retrieval, security/intrusion detection, and applications in Biology and Astrophysics. 
+
+To build a classifier, you'll first need a set of training documents. For a spam/non-spam classifier, this would consist of a number of documents which you have labeled as either spam or not. With training sets, bigger is better. You should probably have at least 100 of each type (spam and not spam). Really 1,000 of each type would be better and 10,000 of each would be super sweet.
+
+==Simple Example
+The Classifier class takes care of all of the messy details for you.  It defaults to a naive bayes classifier and using the Document (best for western natural language) class to represent documents.
+
+	# This example based on the song "Losing My Edge" by LCD Soundsystem
+
+	classifier = Basset::Classifier.new 	#default options
+
+	classifier.train(:hip, "turntables", "techno music", "DJs with turntables", "techno DJs")
+	classifier.train(:unhip, "rock music", "guitar bass drums", "guitar rock", "guitar players")
+	classifier.classify("guitar music") 
+		=> :unhip
+
+	# now everyone likes rock music again! retrain the classifier fast!
+
+	classifier.train_iterative(:hip, "guitars") # takes 3 iterations
+	classifier.classify("guitars")
+		=> :hip
+
+==Full Control
+For more control over the various stages of the training and classification process, you can create document, feature selector, feature extractor, and document classifier objects directly.  The process is as follows:
+
+* Create each as a Document (a class in this library)
+* Pass those documents into the FeatureSelector
+* Get the best features and pass those into the FeatureExtractor
+* Now extract features from each document using the extractor and
+* Pass those extracted features to NaiveBayes or Svm as part of the training set
+* Now you can save the FeatureExtractor and NaiveBayes (or Svm) to a file
+
+That represents the process of selecting features and training the classifier. Once you've done that you can predict if a new previously unseen document is spam or not by just doing the following:
+
+* Load the feature extractor and document classifier from their files
+* Create a new document object from your new unseen document
+* Extract the features from that document using the feature extractor and
+* Pass those to the classify method of the naive bayes classifier
+
+Something that you'll probably want to do before doing real classification is to test things. Use the ClassificationEvaluator for this. Using the evaluator you can pass your training documents in and have it run through a series of tests to give you an estimate of how successful the classifier will be at predicting unseen documents. Easy classification tasks will generally be > 90% accurate while others can be much harder. Each classification task is different and most of the time you won't know until you actually test it out.
+
+=Contact
+I love machine learning and classification so if you have a problem that is giving you trouble don't hesitate to get a hold of me. The same applies for anyone who wants to write additional classifiers, better document representations, or just to tell my my code is amateur.
+
+Author::    Paul Dix  (mailto:paul@pauldix.net)
+Site::      http://www.pauldix.net
+Freenode::  pauldix in #nyc.rb

data/Rakefile

@@ -0,0 +1,63 @@
+require 'rubygems'
+require 'rake/rdoctask'
+require './lib/basset.rb'
+require "spec/rake/spectask"
+require "rake/clean"
+require "rake/rdoctask"
+
+desc "Run all of the specs"
+Spec::Rake::SpecTask.new do |t|
+  t.spec_opts = ['--options', "\"spec/spec.opts\""]
+  t.fail_on_error = false
+end
+
+namespace :spec do
+
+  desc "Run all spec with RCov" 
+  Spec::Rake::SpecTask.new(:rcov) do |t|
+    t.rcov = true
+    t.rcov_dir = 'doc/tools/coverage/'
+    t.rcov_opts = ['--exclude', 'spec']
+  end
+
+  desc "Generate HTML report for failing examples"
+  Spec::Rake::SpecTask.new('report') do |t|
+    t.spec_files = FileList['failing_examples/**/*.rb']
+    t.spec_opts = ["--format", "html:doc/tools/reports/failing_examples.html", "--diff", '--options', '"spec/spec.opts"']
+    t.fail_on_error = false
+  end
+  
+end
+
+
+Rake::RDocTask.new do |rdt|
+  rdt.rdoc_dir = "doc"
+  rdt.main = "README.rdoc"
+  rdt.rdoc_files.include("README.rdoc", "lib/*", "ext/*/*.yy.c")
+end
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |s|
+    s.name = 'basset'
+    s.summary = 'A library for machine learning and classification'
+    s.description = s.summary
+    s.email = 'ddeleo@basecommander.net'
+    s.homepage = "http://github.com/danielsdeleo/basset"
+    s.platform = Gem::Platform::RUBY 
+    s.has_rdoc = true
+    s.extra_rdoc_files = ["README.rdoc"]
+    s.require_path = ["lib"]
+    s.authors = ['Paul Dix', 'Bryan Helmkamp', 'Daniel DeLeo']
+    s.add_dependency('stemmer', '>= 1.0.1') 
+    # ruby -rpp -e' pp `git ls-files`.split("\n") '
+    s.files = `git ls-files`.split("\n").reject {|f| f =~ /git/}
+  end
+rescue LoadError
+  puts "Jeweler not available. Install it with: sudo gem install technicalpickles-jeweler -s http://gems.github.com"
+end
+
+desc "outputs a list of files suitable for use with the gemspec"
+task :list_files do
+  sh %q{ruby -rpp -e' pp `git ls-files`.split("\n").reject {|f| f =~ /git/} '}
+end

data/VERSION.yml

@@ -0,0 +1,4 @@
+--- 
+:major: 1
+:minor: 0
+:patch: 4

data/basset.gemspec

@@ -0,0 +1,32 @@
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{basset}
+  s.version = "1.0.4"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Paul Dix", "Bryan Helmkamp", "Daniel DeLeo"]
+  s.date = %q{2009-05-09}
+  s.description = %q{A library for machine learning and classification}
+  s.email = %q{ddeleo@basecommander.net}
+  s.extra_rdoc_files = ["README.rdoc"]
+  s.files = ["History.txt", "License.txt", "Manifest.txt", "README.rdoc", "Rakefile", "VERSION.yml", "basset.gemspec", "examples/example.rb", "lib/basset.rb", "lib/basset/classification_evaluator.rb", "lib/basset/classifier.rb", "lib/basset/core_extensions.rb", "lib/basset/document.rb", "lib/basset/document_override_example.rb", "lib/basset/feature.rb", "lib/basset/feature_extractor.rb", "lib/basset/feature_selector.rb", "lib/basset/naive_bayes.rb", "lib/basset/svm.rb", "lib/basset/yaml_serialization.rb", "spec/spec.opts", "spec/spec_helper.rb", "spec/unit/classifier_spec.rb", "spec/unit/core_extension_spec.rb", "spec/unit/document_spec.rb", "spec/unit/feature_extractor_spec.rb", "spec/unit/feature_selector_spec.rb", "spec/unit/feature_spec.rb", "spec/unit/naive_bayes_spec.rb", "spec/unit/svm_spec.rb"]
+  s.homepage = %q{http://github.com/danielsdeleo/basset}
+  s.rdoc_options = ["--inline-source", "--charset=UTF-8"]
+  s.require_paths = [["lib"]]
+  s.rubygems_version = %q{1.3.3}
+  s.summary = %q{A library for machine learning and classification}
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+      s.add_runtime_dependency(%q<stemmer>, [">= 1.0.1"])
+    else
+      s.add_dependency(%q<stemmer>, [">= 1.0.1"])
+    end
+  else
+    s.add_dependency(%q<stemmer>, [">= 1.0.1"])
+  end
+end

data/examples/example.rb

@@ -0,0 +1,25 @@
+#!/usr/bin/env ruby
+require File.dirname(__FILE__) + '/../lib/basset.rb'
+
+documents = [
+  Basset::Document.new("ruby is awesome", :ruby),
+  Basset::Document.new("python is good", :python),
+  Basset::Document.new("ruby is fun", :ruby),
+  Basset::Document.new("python is boring", :python)]
+
+# first add the docs to the feature selector
+# The feature selector is tricky. It messes with this kind of toy example since it throws
+# out features that don't occur in enough documents.
+feature_selector = Basset::FeatureSelector.new
+documents.each {|doc| feature_selector.add_document(doc)}
+
+# now create a feature extractor, which expects an array of features on init. This comes
+# from the feature selector
+feature_extractor = Basset::FeatureExtractor.new(feature_selector.best_features)
+
+# now we're ready to set up the classifier
+naive_bayes = Basset::NaiveBayes.new
+documents.each {|doc| naive_bayes.add_document(doc.classification, feature_extractor.extract_numbered(doc))}
+
+test_doc = Basset::Document.new("I like ruby")
+puts naive_bayes.classify(test_doc.vector_of_features).inspect

data/lib/basset.rb

@@ -0,0 +1,9 @@
+$:.unshift(File.dirname(__FILE__))
+
+Dir.glob(File.join(File.dirname(__FILE__), "basset", "*.rb")).each do |file|
+  require file
+end
+
+module Basset
+  VERSION = "1.0.1"
+end

data/lib/basset/classification_evaluator.rb

@@ -0,0 +1,170 @@
+module Basset
+  # Class for running evaluation tests on a classifier, and document 
+  # representation.
+  # Takes the training_documents, which should be an array of objects that can return a vector of features (like Basset::Document)
+  # The args hash has two optional keys {:output => true, :folding_amount => 10} where folding_amount is the amount of cross validation.
+  class ClassificationEvaluator
+    def initialize(training_documents, args = {})
+      args[:output] = true unless args.has_key?(:output)
+      @output_to_console = args[:output]
+      @folding_amount = (args[:folding_amount] or 10)
+      @total_documents_trained = 0
+      @document_sets = split_documents_into_cross_validation_sets(training_documents, @folding_amount)
+    end
+    
+    # Classifiers should be an array of basset classifier objects to run cross validation tests on
+    def test_with_basset_classifiers(classifiers)
+    end
+
+    # Classifiers should be an array of basset classifier objects to run cross validation tests on.
+    # chi_value will be passed on to the feature_selector. The default value of 0 will select all features.
+    # The block will get called and passed in each training_set and test_set from the document_sets. It should 
+    # run some external classifier and return the number of documents from the test_set that were correctly classified.
+    def compare_against_basset_classifiers(classifiers, chi_value = 0, &block)
+      # initialize the results hash
+      results = {"External" => {:correct => 0, :total => 0, :time => 0.0}}
+      classifiers.each {|classifier| results[classifier.class] = {:correct => 0, :total => 0, :time => 0.0}}
+
+      # run on each doc set
+      @document_sets.each_with_index do |document_set, iteration|
+        puts "iteration #{iteration + 1} of #{@document_sets.size}" if @output_to_console
+        feature_extractor = nil
+        feature_extractor_time = time_execution { feature_extractor = create_feature_extractor(document_set[:training_set], chi_value) }
+        number_of_test_documents = document_set[:test_set].size
+        
+        # do a test run on each classifier
+        classifiers.each do |classifier|          
+          correct = 0
+          time = time_execution { correct = test_run(document_set[:training_set], document_set[:test_set], feature_extractor, classifier) } + feature_extractor_time
+          results[classifier.class][:time] += time
+          results[classifier.class][:correct] += correct
+          results[classifier.class][:total] += number_of_test_documents
+          output_results(correct, number_of_test_documents, time, classifier.class) if @output_to_console
+        end
+          
+        # now run the external and gather results
+        correct = 0
+        time = time_execution { correct = block.call(document_set[:training_set], document_set[:test_set]) }
+        results["External"][:time]    += time
+        results["External"][:correct] += correct
+        results["External"][:total]   += number_of_test_documents
+        output_results(correct, number_of_test_documents, time, "External") if @output_to_console
+      end
+      
+      puts "\nFinal Results\n---------------------------------------------------------------------------------------" if @output_to_console
+      puts "Trained on #{@total_documents_trained} documents on #{@folding_amount} cross validation runs." if @output_to_console
+      if @output_to_console
+        results.each_pair {|classifier, results_numbers| output_results(results_numbers[:correct], results_numbers[:total], results_numbers[:time], classifier)}
+      end
+      
+      return results
+    end
+    
+    # It will then feature select and train on 9 and test on 
+    # the other. Iterate 10 times using each block as the test set and the others as the 
+    # training and combine the results.
+    def test_with_cross_validation(training_document_names, folding_amount = 10)
+      # make sure it's not in some order
+      training_document_names.each {|class_documents| class_documents.randomize!}
+    
+      # the folding amount determines how big the test set size is. for 10 fold it's 10% and we run 10 times
+      total_correct, total_documents = 0, 0
+    
+      # there's some tricky code here to make sure that the training and test sets have an equal percentage 
+      # of docs from each class for each iteration.
+      folding_amount.times do |iteration|
+        puts "iteration #{iteration + 1} of #{folding_amount}" if @output_to_console
+        test_set = []
+        training_document_names.each do |class_document_names|
+          test_set_size = (class_document_names.size / folding_amount).to_i
+          test_set << class_document_names.slice(iteration * test_set_size, test_set_size)
+        end
+        training_set = []
+        training_document_names.each_with_index {|class_document_names, i| training_set += (class_document_names - test_set[i])}
+        test_set = test_set.flatten
+      
+        correct, total = test_run(training_set, test_set)
+        total_correct += correct
+        total_documents += total
+      end
+
+      output_results(total_correct, total_documents) if @output_to_console
+      return [total_correct, total_documents]
+    end
+
+  private
+    # Splits entire set. The goal here is to test classification accuracy
+    # using cross validation. 10 fold is the default. So it will split the training set
+    # into 10 equal size chunks.
+    # training_documents is actually an array of arrays. each class to be considered
+    # has an array of documents.
+    def split_documents_into_cross_validation_sets(training_documents, folding_amount = 10)
+      document_sets = []
+      # make sure it's not in some order
+      training_documents.each {|class_documents| class_documents.randomize!}
+  
+      # the folding amount determines how big the test set size is. for 10 fold it's 10% and we run 10 times
+      # there's some tricky code here to make sure that the training and test sets have an equal percentage 
+      # of docs from each class for each iteration.
+      folding_amount.times do |iteration|
+        test_set = []
+        training_documents.each do |class_documents|
+          test_set_size = (class_documents.size / folding_amount).to_i
+          test_set << class_documents.slice(iteration * test_set_size, test_set_size)
+        end
+        training_set = []
+        training_documents.each_with_index {|class_documents, i| training_set += (class_documents - test_set[i])}
+        test_set = test_set.flatten
+        @total_documents_trained += training_set.size
+        document_sets << {:training_set => training_set, :test_set => test_set}
+      end
+      return document_sets
+    end
+
+    # this method returns a feature extractor for the passed in training_set using the chi_value
+    def create_feature_extractor(training_set, chi_value)
+      feature_selector = FeatureSelector.new
+      # select features based on training set
+      training_set.each do |document| 
+        feature_selector.add_document(document)
+      end
+      if chi_value == 0
+        selected_features = feature_selector.all_feature_names
+      else
+        selected_features = feature_selector.select_features(chi_value)
+      end
+      puts "selected #{selected_features.size} of #{feature_selector.number_of_features} features for this iteration" if @output_to_console
+      return FeatureExtractor.new(selected_features)      
+    end
+    
+    # this is a single run on a training and test set. It will run feature_selection, the feature_extraction, then training, then testing
+    def test_run(training_set, testing_set, feature_extractor, classifier)
+      puts "training #{classifier.class} on #{training_set.size} documents..." if @output_to_console
+      # now train the classifier
+      training_set.each do |document| 
+        classifier.add_document(document.classification, feature_extractor.extract_numbered(document) )
+      end
+
+      puts "running #{classifier.class} on #{testing_set.size} documents..." if @output_to_console
+      # now classify test set
+      number_correctly_classified = 0
+      testing_set.each do |document|
+        score, predicted_classification = classifier.classify(feature_extractor.extract_numbered(document))
+        number_correctly_classified += 1 if document.classification == predicted_classification
+      end
+
+      return number_correctly_classified
+    end
+  
+    def output_results(correct, total, time, classifier_name)
+      puts "#{classifier_name} classified #{correct} of #{total} correctly for #{(correct/total.to_f * 100).to_s_decimal_places(2)}% accurcy. Executed run in #{time.to_s_decimal_places(1)} seconds."
+    end
+  
+    def time_execution(&block)
+      start_time = Time.now
+      yield
+      end_time = Time.now
+      return end_time - start_time 
+    end
+  end
+end

data/lib/basset/classifier.rb

@@ -0,0 +1,188 @@
+require "basset/yaml_serialization"
+
+module Basset
+  
+  #
+  # Classifier wraps up all of the operations spread between Document and friends,
+  # FeatureExtractor, FeatureSelector, and specific classifiers such as 
+  # NaiveBayes into one convenient interface.
+  #
+  class Classifier
+    include YamlSerialization
+    
+    DEFAULTS = {:type => "naive_bayes", :doctype => "document"}
+    
+    attr_reader :engine, :doctype
+    
+    #
+    # Create a new classifier object.  You can specify the type of classifier
+    # and kind of documents with the options.  The defaults are 
+    # :type => :naive_bayes, :doctype => :document; There is also a uri_document,ie.
+    # opts: {:type => :naive_bayes, :doctype => :uri_document }
+    def initialize(opts={})
+      @engine = constanize_opt(opts[:type] || DEFAULTS[:type]).new
+      @doctype = constanize_opt(opts[:doctype] || DEFAULTS[:doctype])
+    end
+    
+    #
+    # Trains the classifier with _texts_ of class _classification_.
+    # _texts_ gets flattened, so you can pass in an array without breaking
+    # anything.
+    def train(classification, *texts)
+      texts.flatten.each do |text| 
+        train_with_features(classification, features_of(text, classification))
+      end
+    end
+    
+    # 
+    # Trains the classifier on a text repeatedly until the classifier recognizes
+    # it as being in class _classification_ (up to a maximum of 5 retrainings).
+    # Handy for training the classifier quickly or when it has been mistrained.
+    def train_iterative(classification, text)
+      (1 .. 5).each do |i|
+        train(classification, text)
+        break if classify(text) == classification
+      end
+    end
+    
+    # 
+    # Classifies _text_ based on training
+    def classify(text)
+      classify_features(features_of(text)).last
+    end
+    
+    #
+    # Gives a numeric value for the similarity of _text_ to previously seen
+    # texts of class _classification_.  For a Naive Bayes filter, this will
+    # be the log10 of the probabilities of each token in _text_ occuring in
+    # a text of class _classification_, normalized for the number of tokens.
+    def similarity_score(classification, text)
+      similarity_score_for_features(classification, features_of(text))
+    end
+    
+    def ==(other)
+      other.is_a?(self.class) && other.engine == engine && other.doctype == doctype
+    end
+    
+    private
+    
+    def train_with_features(classification, features)
+      @engine.add_document(classification, features)
+    end
+    
+    def classify_features(features)
+      @engine.classify(features)
+    end
+    
+    def similarity_score_for_features(classification, features)
+      @engine.probability_of_vectors_for_class(features, classification, :normalize => true)      
+    end
+    
+    def features_of(text, classification=nil)
+      @doctype.new(text, classification).feature_vectors
+    end
+    
+    # poor man's version of Rails' String#classify.constantize
+    def constanize_opt(option)
+      class_name = option.to_s.split('_').map { |word| word.capitalize }.join('')
+      Basset.class_eval class_name
+    end
+    
+  end
+  
+  #
+  # A class for anomaly detection.  
+  #
+  # The purpose of this is to enable a statistical machine learning approach
+  # even when you can't/don't want to assume that "abnormal" documents will
+  # have certain features or fit nicely into classes.
+  # 
+  # An example use case is an anomaly based IDS where you don't want to classify
+  # different kinds of attacks but instead want to find all events that deviate
+  # from an established baseline.
+  # 
+  # With the default NaiveBayes classification method, uses the log10 of the 
+  # Bayesian probability of a document belonging to the normal behavior group 
+  # as a distance measurement; any document with a distance measurement higher
+  # than a given threshold is considered anomalous.
+  class AnomalyDetector < Classifier
+    include YamlSerialization
+    
+    def initialize(opts={})
+      @training_features=[]
+      @updated = true
+      super(opts)
+    end
+    
+    def classify(text)
+      anomalous?(text) ? :anomalous : :normal
+    end
+    
+    def anomalous?(text)
+      minimum_acceptable_score > similarity_score(text)
+    end
+    
+    def normal?(text)
+      !anomalous?(text)
+    end
+    
+    def train(*texts)
+      texts.flatten.each do |text|
+        features = features_of(text)
+        @training_features << features
+        train_with_features(:normal, features)
+      end
+      reset_memoized_values
+    end
+    
+    def similarity_score(text)
+      super(:normal, text)
+    end
+    
+    # Gives the number of standard deviations from average 
+    def anomaly_score(text)
+      -1 * similarity_score(text) / stddev_of_scores_of_training_set
+    end
+    
+    def scores_for_training_set
+      unless @scores_for_training_set
+        @scores_for_training_set = @training_features.map { |feature_set| similarity_score_for_features(:normal, feature_set)}
+        stddev_of_scores_of_training_set
+      end
+      @scores_for_training_set
+    end
+    
+    def avg_score_of_training_set
+      scores_for_training_set.inject(0) { |sum, score| sum += score } / scores_for_training_set.length.to_f
+    end
+    
+    def score_range_of_training_set
+      scores_for_training_set.min .. scores_for_training_set.max
+    end
+    
+    def stddev_of_scores_of_training_set
+      unless @stddev_of_scores_of_training_set
+        @stddev_of_scores_of_training_set = Math.stddev(scores_for_training_set)
+      end
+      @stddev_of_scores_of_training_set
+    end
+    
+    def minimum_acceptable_score
+      avg_score_of_training_set - (4 * stddev_of_scores_of_training_set)
+    end
+    
+    def train_iterative(text)
+      (1 .. 5).each do
+        train(text)
+        break if normal?(text)
+      end
+    end
+    
+    def reset_memoized_values
+      @memoized_vals_stale = true
+      @stddev_of_scores_of_training_set = nil
+      @scores_for_training_set = nil
+    end
+    
+  end
+end