stamina 0.3.0 → 0.3.1

data/CHANGELOG.md

@@ -1,3 +1,18 @@
+# 0.3.1 / 2011-03-24
+
+* Major Enhancements
+
+    * Implemented the decoration algorithm of Damas10, allowing to decorate states
+      with information propagated from states to states until a fixpoint is reached.
+    * Added Automaton::Metrics module, automatically included, with useful metrics
+      like automaton depth, accepting ratio and so on.
+    * Added Scoring module and Classifier#classification_scoring(sample) method
+      with common measures from information retrieval.
+
+* On the devel side
+
+    * Moved specific automaton tests under test/stamina/automaton/...
+
 # 0.3.0 / 2011-03-24
 
 * On the devel side

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    stamina (0.3.0)
+    stamina (0.3.1)
 
 GEM
   remote: http://rubygems.org/

data/lib/stamina.rb

@@ -13,6 +13,8 @@ require 'stamina/sample'
 require 'stamina/input_string'
 require 'stamina/classifier'
 require 'stamina/automaton'
+require 'stamina/scoring'
+require 'stamina/utils'
 require 'stamina/induction/union_find'
 require 'stamina/induction/commons'
 require "stamina/induction/rpni"

data/lib/stamina/automaton.rb

@@ -1234,4 +1234,5 @@ module Stamina
   end # class Automaton
     
 end # module Stamina
-require 'stamina/automaton/walking'
+require 'stamina/automaton/walking'
+require 'stamina/automaton/metrics'

data/lib/stamina/automaton/metrics.rb

@@ -0,0 +1,71 @@
+require 'stamina/utils/decorate'
+module Stamina
+  class Automaton
+    #
+    # Provides useful metric methods on automata.
+    #
+    # This module is automatically included by Automaton and is not intended
+    # to be used directly.
+    # 
+    module Metrics
+      
+      #
+      # Returns the number of letters of the alphabet.
+      # 
+      def alphabet_size
+        alphabet.size
+      end
+      
+      #
+      # Returns the average degree of states, that is, 
+      # <code>edge_count/state_count</code>
+      #
+      def avg_degree
+        edge_count.to_f/state_count.to_f
+      end
+      alias :avg_out_degree :avg_degree
+      alias :avg_in_degree :avg_degree
+      
+      #
+      # Number of accepting states over all states
+      #
+      def accepting_ratio
+        states.select{|s|s.accepting?}.size.to_f/state_count.to_f
+      end
+      
+      # 
+      # Number of error states over all states
+      #
+      def error_ratio
+        states.select{|s|s.error?}.size.to_f/state_count.to_f
+      end
+      
+      #
+      # Computes the depth of the automaton.
+      #
+      # The depth of an automaton is defined as the length of the longest shortest 
+      # path from the initial state to a state.
+      #
+      # This method has a side effect on state marks, as it keeps the depth of
+      # each state as a mark under _key_, which defaults to :depth.
+      #
+      def depth(key = :depth)
+        algo = Stamina::Utils::Decorate.new(key)
+        algo.set_suppremum do |d0,d1|
+          if d0.nil?
+            d1
+          elsif d1.nil?
+            d0
+          else
+            (d0 <= d1 ? d0 : d1)
+          end
+        end
+        algo.set_propagate {|d,e| d+1 }
+        algo.execute(self, nil, 0)
+        states.max{|s0,s1| s0[:depth] <=> s1[:depth]}[:depth]
+      end
+      
+    end # module Metrics
+    include Metrics
+  end # class Automaton
+end # module Stamina

data/lib/stamina/classifier.rb

@@ -20,6 +20,21 @@ module Stamina
       end
       signature
     end
+    alias :classification_signature :signature
+
+    #
+    # Classifies a sample then compute the classification scoring that is obtained
+    # by comparing the signature obtained by classification and the one of the sample
+    # itself. Returns an object responding to methods defined in Scoring module.
+    #
+    # This method is actually a convenient shortcut for:
+    #
+    #    Stamina::Scoring.scoring(signature(sample), sample.signature)
+    #
+    def scoring(sample)
+      Stamina::Scoring.scoring(signature(sample), sample.signature)
+    end
+    alias :classification_scoring :scoring
     
     # 
     # Checks if a labeled sample is correctly classified by the classifier.
@@ -34,4 +49,4 @@ module Stamina
     end
     
   end # module Classifier
-end # module Stamina
+end # module Stamina

data/lib/stamina/scoring.rb

@@ -0,0 +1,176 @@
+module Stamina
+  #
+  # Provides utility methods for scoring binary classifiers from signatures
+  #
+  module Scoring
+
+      #
+      # From the signatures of a learned model and a actual, returns an object 
+      # responding to all instance methods defined in the Scoring module.
+      #
+      def self.scoring(learned, actual, max_size=nil)
+        unless learned.size==actual.size
+          raise ArgumentError, "Signatures must be of same size (#{learned.size} vs. #{actual.size})"
+        end
+        max_size ||= learned.size
+        max_size = learned.size if max_size > learned.size
+        tp, fn, fp, tn = 0, 0, 0, 0
+        (0...max_size).each do |i|
+          positive, labeled_as = actual[i..i]=='1', learned[i..i]=='1'
+          if positive==labeled_as
+            positive ? (tp += 1) : (tn += 1)
+          else
+            positive ? (fn += 1) : (fp += 1)
+          end
+        end
+        measures = { :true_positive  => tp,
+                     :true_negative  => tn,
+                     :false_positive => fp,
+                     :false_negative => fn }
+        measures.extend(Scoring)
+        measures
+      end
+
+      #
+      # Returns the number of positive strings correctly labeled as positive
+      #
+      def true_positive
+        self[:true_positive]
+      end
+
+      #
+      # Returns the number of negative strings correctly labeled as negative.
+      #
+      def true_negative
+        self[:true_negative]
+      end
+
+      #
+      # Returns the number of negative strings incorrectly labeled as positive.
+      #
+      def false_positive
+        self[:false_positive]
+      end
+
+      #
+      # Returns the number of positive strings incorrectly labeled as negative.
+      #
+      def false_negative
+        self[:false_negative]
+      end
+
+      #
+      # Returns the percentage of positive predictions that are correct
+      #
+      def precision
+        true_positive.to_f/(true_positive + false_positive)
+      end
+      alias :positive_predictive_value :precision
+
+      #
+      # Returns the percentage of true negative over all negative
+      # 
+      def negative_predictive_value
+        true_negative.to_f / (true_negative + false_negative)
+      end
+
+      #
+      # Returns the percentage of positive strings that were predicted as being
+      # positive
+      #
+      def recall
+        true_positive.to_f / (true_positive + false_negative)
+      end
+      alias :sensitivity :recall
+      alias :true_positive_rate :recall
+
+      #
+      # Returns the percentage of negative strings that were predicted as being
+      # negative
+      #
+      def specificity
+        true_negative.to_f / (true_negative + false_positive)
+      end
+      alias :true_negative_rate :specificity
+
+      #
+      # Returns the percentage of false positives
+      #
+      def false_positive_rate
+        false_positive.to_f / (false_positive + true_negative)
+      end
+
+      #
+      # Returns the percentage of false negatives
+      #
+      def false_negative_rate
+        false_negative.to_f / (true_positive + false_negative)
+      end
+
+      #
+      # Returns the likelihood that a predicted positive is an actual positive
+      # 
+      def positive_likelihood
+        sensitivity / (1.0 - specificity)
+      end
+
+      #
+      # Returns the likelihood that a predicted negative is an actual negative
+      # 
+      def negative_likelihood
+       (1.0 - sensitivity) / specificity
+      end
+
+      #
+      # Returns the percentage of predictions that are correct
+      #
+      def accuracy
+        num = (true_positive + true_negative).to_f
+        den = (true_positive + true_negative + false_positive + false_negative)
+        num / den
+      end
+
+      #
+      # Returns the error rate
+      # 
+      def error_rate
+        num = (false_positive + false_negative).to_f
+        den = (true_positive + true_negative + false_positive + false_negative)
+        num / den
+      end
+
+      #
+      # Returns the harmonic mean between precision and recall
+      #
+      def f_measure 
+        2.0 * (precision * recall) / (precision + recall)
+      end
+
+      #
+      # Returns the balanced classification rate (arithmetic mean between 
+      # sensitivity and specificity)
+      # 
+      def balanced_classification_rate
+        0.5 * (sensitivity + specificity)
+      end
+      alias :bcr :balanced_classification_rate
+
+      #
+      # Returns the balanced error rate (1 - bcr)
+      # 
+      def balanced_error_rate
+        1.0 - balanced_classification_rate
+      end
+      alias :ber :balanced_error_rate
+
+      #
+      # Returns the harmonic mean between sensitivity and specificity
+      # 
+      def harmonic_balanced_classification_rate
+        2.0 * (sensitivity * specificity) / (sensitivity + specificity)
+      end
+      alias :hbcr :harmonic_balanced_classification_rate
+      alias :harmonic_bcr :harmonic_balanced_classification_rate
+    
+  end # module Scoring
+end # module Stamina

data/lib/stamina/utils.rb

@@ -0,0 +1 @@
+require 'stamina/utils/decorate'

data/lib/stamina/utils/decorate.rb

@@ -0,0 +1,81 @@
+module Stamina
+  module Utils
+    #
+    # Decorates states of an automaton by applying a propagation rule 
+    # until a fix point is reached.
+    #
+    class Decorate
+      
+      # The key to use to maintain the decoration on states (:invariant
+      # is used by default)
+      attr_writer :decoration_key
+      
+      # Creates a decoration algorithm instance
+      def initialize(decoration_key = :invariant)
+        @decoration_key = decoration_key
+        @suppremum = nil
+        @propagate = nil
+      end
+      
+      # Installs a suppremum function through a block.
+      def set_suppremum(&block)
+        raise ArgumentError, 'Suppremum expected through a block' if block.nil?
+        raise ArgumentError, 'Block of arity 2 expected' unless block.arity==2
+        @suppremum = block
+      end
+      
+      # Installs a propagate function through a block.
+      def set_propagate(&block)
+        raise ArgumentError, 'Propagate expected through a block' if block.nil?
+        raise ArgumentError, 'Block of arity 2 expected' unless block.arity==2
+        @propagate = block
+      end
+      
+      # Computes the suppremum between two decorations. By default, this method
+      # looks for a suppremum function installed with set_suppremum. If not found,
+      # it tries calling a suppremum method on d0. If not found it raises an error. 
+      # This method may be overriden.
+      def suppremum(d0, d1)
+        return @suppremum.call(d0, d1) if @suppremum
+        return d0.suppremum(d1) if d0.respond_to?(:suppremum)
+        raise "No suppremum function installed or implemented by decorations"
+      end
+      
+      # Computes the propagation rule. By default, this method looks for a propagate 
+      # function installed with set_propagate. If not found, it tries calling a + 
+      # method on deco. If not found it raises an error. 
+      # This method may be overriden.
+      def propagate(deco, edge)
+        return @propagate.call(deco, edge) if @propagate
+        return deco.+(edge) if deco.respond_to?(:+)
+        raise "No propagate function installed or implemented by decorations"
+      end
+      
+      # Executes the propagation algorithm on a given automaton.
+      def execute(fa, bottom, d0)
+        # install initial decoration
+        fa.states.each do |s|
+          s[@decoration_key] = (s.initial? ? d0 : bottom)
+        end
+        
+        # fix-point loop starting with initial states
+        to_explore = fa.initial_states
+        until to_explore.empty?
+          source = to_explore.pop
+          source.out_edges.each do |edge|
+            target = edge.target
+            p_decor = propagate(source[@decoration_key], edge)
+            p_decor = suppremum(target[@decoration_key], p_decor)
+            unless p_decor == target[@decoration_key]
+              target[@decoration_key] = p_decor
+              to_explore << target unless to_explore.include?(target)
+            end
+          end
+        end
+        
+        fa
+      end
+      
+    end # class Decorate
+  end # module Utils
+end # module Stamina

data/lib/stamina/version.rb

@@ -3,7 +3,7 @@ module Stamina
   
     MAJOR = 0
     MINOR = 3
-    TINY  = 0
+    TINY  = 1
   
     def self.to_s
       [ MAJOR, MINOR, TINY ].join('.')

data/stamina.noespec

@@ -9,7 +9,7 @@ variables:
   upper:
     Stamina
   version:
-    0.3.0
+    0.3.1
   summary: |-
     Automaton and Regular Inference Toolkit
   description: |-

data/test/stamina/{automaton_classifier_test.rb → automaton/classifier_test.rb}

@@ -150,6 +150,110 @@ module Stamina
         assert_equal(false, @small_nfa.correctly_classify?(sample))
       end
   
+      def test_scoring_on_valid_sample
+        sample = ADL::parse_sample <<-SAMPLE
+          -
+          + b
+          + b c
+          - b c a
+          - b c a c
+          - b c a c a
+          - b c a a
+          + b c a b
+          + b c a b c a c b
+          - z
+          - b z
+        SAMPLE
+        measures = @small_dfa.scoring(sample)
+        assert_equal(sample.positive_count, measures.true_positive)
+        assert_equal(0, measures.false_positive)
+        assert_equal(sample.negative_count, measures.true_negative)
+        assert_equal(0, measures.false_negative)
+        assert_equal(1.0, measures.precision)  
+        assert_equal(1.0, measures.recall)  
+        assert_equal(1.0, measures.sensitivity)  
+        assert_equal(1.0, measures.specificity)  
+        assert_equal(1.0, measures.accuracy)
+      end
+
+      def test_scoring_on_invalid_sample
+        sample = ADL::parse_sample <<-SAMPLE
+          +
+          - b
+          - b c
+          + b c a
+          + b c a c
+          + b c a c a
+          + b c a a
+          - b c a b
+          - b c a b c a c b
+          + z
+          + b z
+        SAMPLE
+        measures = @small_dfa.scoring(sample)
+        assert_equal(0.0, measures.true_positive)
+        assert_equal(sample.negative_count, measures.false_positive)
+        assert_equal(0.0, measures.true_negative)
+        assert_equal(sample.positive_count, measures.false_negative)
+        assert_equal(0.0, measures.precision)  
+        assert_equal(0.0, measures.recall)  
+        assert_equal(0.0, measures.sensitivity)  
+        assert_equal(0.0, measures.specificity)  
+        assert_equal(0.0, measures.accuracy)
+      end
+
+      def test_scoring_with_positive_only
+        sample = ADL::parse_sample <<-SAMPLE
+          +
+          + b
+          + b c
+          + b c a
+          + b c a c
+          + b c a c a
+          + b c a a
+          + b c a b
+          + b c a b c a c b
+          + z
+          + b z
+        SAMPLE
+        measures = @small_dfa.scoring(sample)
+        assert_equal(4.0, measures.true_positive)
+        assert_equal(sample.size-sample.positive_count, measures.false_positive)
+        assert_equal(0, measures.true_negative)
+        assert_equal(sample.size-4.0, measures.false_negative)
+        assert_equal(1.0, measures.precision)  
+        assert_equal(4.0/sample.size, measures.recall)  
+        assert_equal(4.0/sample.size, measures.sensitivity)  
+        #assert_equal(0.0/0.0, measures.specificity)  
+        assert_equal(4.0/sample.size, measures.accuracy)
+      end
+      
+      def test_scoring_with_negative_only
+        sample = ADL::parse_sample <<-SAMPLE
+          -
+          - b
+          - b c
+          - b c a
+          - b c a c
+          - b c a c a
+          - b c a a
+          - b c a b
+          - b c a b c a c b
+          - z
+          - b z
+        SAMPLE
+        measures = @small_dfa.scoring(sample)
+        assert_equal(0.0, measures.true_positive)
+        assert_equal(4.0, measures.false_positive)
+        assert_equal(sample.size-4.0, measures.true_negative)
+        assert_equal(0.0, measures.false_negative)
+        assert_equal(0.0, measures.precision)  
+        #assert_equal(0.0, measures.recall)  
+        #assert_equal(0.0, measures.sensitivity)  
+        assert_equal((sample.size-4.0)/sample.size, measures.specificity)  
+        assert_equal((sample.size-4.0)/sample.size, measures.accuracy)
+      end
+
     end # class ClassifierTest
   end # class Automaton
-end # module Stamina
+end # module Stamina

data/test/stamina/automaton/metrics_test.rb

@@ -0,0 +1,36 @@
+require 'test/unit'
+require 'stamina/adl'
+require 'stamina/stamina_test'
+module Stamina
+  class Automaton
+    class MetricsTest < StaminaTest
+
+      def test_alphabet_size
+        assert_equal 3, @small_dfa.alphabet_size
+      end
+
+      def test_avg_degree
+        assert_equal 6.to_f/4, @small_dfa.avg_degree
+      end
+
+      def test_avg_out_degree
+        assert_equal 6.to_f/4, @small_dfa.avg_out_degree
+      end
+
+      def test_avg_in_degree
+        assert_equal 6.to_f/4, @small_dfa.avg_in_degree
+      end
+
+      def test_accepting_ratio
+        assert_equal 0.5, @small_dfa.accepting_ratio
+      end
+
+      def test_depth
+        assert_equal 3, @small_dfa.depth
+        assert_equal 2, @small_nfa.depth
+      end
+
+    end
+  end
+end
+

data/test/stamina/sample_test.rb

@@ -3,216 +3,213 @@ require 'stamina/errors'
 require 'stamina/stamina_test'
 require 'stamina/sample'
 module Stamina
-
-# Tests Sample class
-class SampleTest < StaminaTest
-  
-  # Converts a String to an InputString
-  def s(str)
-    Stamina::ADL::parse_string(str)
-  end
-  
-  # Tests Sample#empty?
-  def test_empty
-    assert_equal(true, Sample.new.empty?)
-    assert_equal(true, Sample[].empty?)
-    assert_equal(false, Sample['?'].empty?)
-    assert_equal(false, Sample['-'].empty?)
-    assert_equal(false, Sample['+'].empty?)
-    assert_equal(false, Sample['+ a b'].empty?)
-    assert_equal(false, Sample['+ a b', '- a'].empty?)
-    assert_equal(false, Sample['- a b'].empty?)
-  end
-  
-  # Tests Sample#size
-  def test_size_and_counts
-    s = Sample.new
-    assert_equal(0, s.size)
-    assert_equal(0, s.positive_count)
-    assert_equal(0, s.negative_count)
-    s << '+ a b'
-    assert_equal(1, s.size)
-    assert_equal(1, s.positive_count)
-    assert_equal(0, s.negative_count)
-    s << '+ a b'
-    assert_equal(2, s.size)
-    assert_equal(2, s.positive_count)
-    assert_equal(0, s.negative_count)
-    s << '+ a'
-    assert_equal(3, s.size)
-    assert_equal(3, s.positive_count)
-    assert_equal(0, s.negative_count)
-    s << '- a b c'
-    assert_equal(4, s.size)
-    assert_equal(3, s.positive_count)
-    assert_equal(1, s.negative_count)
-  end
-  
-  def test_same_string_can_be_added_many_times
-    s = Sample.new
-    10.times {|i| s << "+ a b"}
-    assert_equal(10, s.size)
-    assert_equal(10, s.positive_count)
-    assert_equal(0, s.negative_count)
-    strings = s.collect{|s| s}
-    assert_equal 10, strings.size
-  end
-  
-  # Tests Sample#<<
-  def test_append
-    s = Sample.new
-    assert_equal(s,s << '+',"Accepts empty string")
-    assert_equal(s,s << '+ a b a b a',"Accepts positive string")
-    assert_equal(s,s << '- a',"Accepts negative string")
-    assert_equal(s,s << '? a',"Accepts unlabeled string")
-  end
-  
-  # Tests Sample#include? on every kind of arguments it announce
-  def test_append_accepts_arguments_it_annouce
-    expected = Sample[
-      '+ a b a b', 
-      '+ a b',
-      '-',
-      '- a',
-      '+ a b a b a b'
-    ]
-    s = Sample.new
-    s << '+ a b a b'
-    s << ['+ a b', '-']
-    s << InputString.new('a', false)
-    s << Sample['+ a b a b a b', '-']
-    assert_equal(expected,s)
-  end
-  
-  # Tests that Sample#<< detects inconsistencies
-  # def test_append_detects_inconsistency
-  #   s = Sample.new
-  #   s << '+ a b'
-  #   s << '+ a b a b'
-  #   assert_raise InconsistencyError do
-  #     s << '- a b a b'
-  #   end
-  # end
-  
-  # Tests that Sample#<< detects inconsistencies
-  def test_append_detects_real_inconsistencies_only
-    s = Sample.new
-    s << '+ a b'
-    s << '+ a b a b'
-    assert_nothing_raised do
-      s << '- b'
-      s << '- a'
-      s << '- a b a'
+  class SampleTest < StaminaTest
+    
+    # Converts a String to an InputString
+    def s(str)
+      Stamina::ADL::parse_string(str)
+    end
+    
+    # Tests Sample#empty?
+    def test_empty
+      assert_equal(true, Sample.new.empty?)
+      assert_equal(true, Sample[].empty?)
+      assert_equal(false, Sample['?'].empty?)
+      assert_equal(false, Sample['-'].empty?)
+      assert_equal(false, Sample['+'].empty?)
+      assert_equal(false, Sample['+ a b'].empty?)
+      assert_equal(false, Sample['+ a b', '- a'].empty?)
+      assert_equal(false, Sample['- a b'].empty?)
+    end
+    
+    # Tests Sample#size
+    def test_size_and_counts
+      s = Sample.new
+      assert_equal(0, s.size)
+      assert_equal(0, s.positive_count)
+      assert_equal(0, s.negative_count)
+      s << '+ a b'
+      assert_equal(1, s.size)
+      assert_equal(1, s.positive_count)
+      assert_equal(0, s.negative_count)
+      s << '+ a b'
+      assert_equal(2, s.size)
+      assert_equal(2, s.positive_count)
+      assert_equal(0, s.negative_count)
+      s << '+ a'
+      assert_equal(3, s.size)
+      assert_equal(3, s.positive_count)
+      assert_equal(0, s.negative_count)
+      s << '- a b c'
+      assert_equal(4, s.size)
+      assert_equal(3, s.positive_count)
+      assert_equal(1, s.negative_count)
+    end
+    
+    def test_same_string_can_be_added_many_times
+      s = Sample.new
+      10.times {|i| s << "+ a b"}
+      assert_equal(10, s.size)
+      assert_equal(10, s.positive_count)
+      assert_equal(0, s.negative_count)
+      strings = s.collect{|s| s}
+      assert_equal 10, strings.size
+    end
+    
+    # Tests Sample#<<
+    def test_append
+      s = Sample.new
+      assert_equal(s,s << '+',"Accepts empty string")
+      assert_equal(s,s << '+ a b a b a',"Accepts positive string")
+      assert_equal(s,s << '- a',"Accepts negative string")
+      assert_equal(s,s << '? a',"Accepts unlabeled string")
+    end
+    
+    # Tests Sample#include? on every kind of arguments it announce
+    def test_append_accepts_arguments_it_annouce
+      expected = Sample[
+        '+ a b a b', 
+        '+ a b',
+        '-',
+        '- a',
+        '+ a b a b a b'
+      ]
+      s = Sample.new
+      s << '+ a b a b'
+      s << ['+ a b', '-']
+      s << InputString.new('a', false)
+      s << Sample['+ a b a b a b', '-']
+      assert_equal(expected,s)
     end
-  end  
-  
-  # Tests each
-  def test_each
-    strings = ['+ a b a b', '+ a b', '+ a b', '- a', '+']
-    strings = strings.collect{|s| ADL::parse_string(s)}
-    s = Sample.new << strings
-    count = 0
-    s.each do |str|
-      assert_equal(true, strings.include?(str))
-      count += 1
+    
+    # Tests that Sample#<< detects inconsistencies
+    # def test_append_detects_inconsistency
+    #   s = Sample.new
+    #   s << '+ a b'
+    #   s << '+ a b a b'
+    #   assert_raise InconsistencyError do
+    #     s << '- a b a b'
+    #   end
+    # end
+    
+    # Tests that Sample#<< detects inconsistencies
+    def test_append_detects_real_inconsistencies_only
+      s = Sample.new
+      s << '+ a b'
+      s << '+ a b a b'
+      assert_nothing_raised do
+        s << '- b'
+        s << '- a'
+        s << '- a b a'
+      end
+    end  
+    
+    # Tests each
+    def test_each
+      strings = ['+ a b a b', '+ a b', '+ a b', '- a', '+']
+      strings = strings.collect{|s| ADL::parse_string(s)}
+      s = Sample.new << strings
+      count = 0
+      s.each do |str|
+        assert_equal(true, strings.include?(str))
+        count += 1
+      end
+      assert_equal(strings.size, count)
     end
-    assert_equal(strings.size, count)
-  end
-  
-  # Tests each_positive
-  def test_each_positive
-    sample = Sample[
-      '+',
-      '- b',
-      '+ a b a b',
-      '- a b a a'
-    ]
-    count = 0
-    sample.each_positive do |str|
-      assert str.positive?
-      count += 1
+    
+    # Tests each_positive
+    def test_each_positive
+      sample = Sample[
+        '+',
+        '- b',
+        '+ a b a b',
+        '- a b a a'
+      ]
+      count = 0
+      sample.each_positive do |str|
+        assert str.positive?
+        count += 1
+      end
+      assert_equal 2, count
+      positives = sample.positive_enumerator.collect{|s| s}
+      assert_equal 2, positives.size
+      [s('+'), s('+ a b a b')].each do |str|
+        assert positives.include?(str)
+      end
     end
-    assert_equal 2, count
-    positives = sample.positive_enumerator.collect{|s| s}
-    assert_equal 2, positives.size
-    [s('+'), s('+ a b a b')].each do |str|
-      assert positives.include?(str)
+    
+    # Tests each_negative
+    def test_each_negative
+      sample = Sample[
+        '+',
+        '- b',
+        '+ a b a b',
+        '- a b a a'
+      ]
+      count = 0
+      sample.each_negative do |str|
+        assert str.negative?
+        count += 1
+      end
+      assert_equal 2, count
+      negatives = sample.negative_enumerator.collect{|s| s}
+      assert_equal 2, negatives.size
+      [s('- b'), s('- a b a a')].each do |str|
+        assert negatives.include?(str)
+      end
     end
-  end
-  
-  # Tests each_negative
-  def test_each_negative
-    sample = Sample[
-      '+',
-      '- b',
-      '+ a b a b',
-      '- a b a a'
-    ]
-    count = 0
-    sample.each_negative do |str|
-      assert str.negative?
-      count += 1
+    
+    # Tests Sample#include?
+    def test_include
+      strings = ['+ a b a b', '+ a b', '- a', '+']
+      s = Sample.new << strings
+      strings.each do |str|
+        assert_equal(true, s.include?(str))
+      end
+      assert_equal(true, s.include?(strings))
+      assert_equal(true, s.include?(s))
+      assert_equal(false, s.include?('+ a'))
+      assert_equal(false, s.include?('-'))
+      assert_equal(false, s.include?('+ a b a'))
     end
-    assert_equal 2, count
-    negatives = sample.negative_enumerator.collect{|s| s}
-    assert_equal 2, negatives.size
-    [s('- b'), s('- a b a a')].each do |str|
-      assert negatives.include?(str)
+    
+    # Tests Sample#include? on every kind of arguments it announce
+    def test_include_accepts_arguments_it_annouce
+      s = Sample.new << ['+ a b a b', '+ a b', '- a', '+']
+      assert_equal true, s.include?('+ a b a b')
+      assert_equal true, s.include?(InputString.new('a b a b',true))
+      assert_equal true, s.include?(ADL::parse_string('+ a b a b'))
+      assert_equal true, s.include?(['+ a b a b', '+ a b'])
+      assert_equal true, s.include?(s)
     end
-  end
-  
-  # Tests Sample#include?
-  def test_include
-    strings = ['+ a b a b', '+ a b', '- a', '+']
-    s = Sample.new << strings
-    strings.each do |str|
-      assert_equal(true, s.include?(str))
+    
+    # Tests Sample#==
+    def test_equal
+      s1 = Sample['+ a b a b', '+', '- a']
+      s2 = Sample['+ a b a b', '+', '+ a']
+      assert_equal(true, s1==s1)
+      assert_equal(true, s2==s2)
+      assert_equal(false, s1==s2)
+      assert_equal(false, s1==Sample.new)
+      assert_equal(false, s2==Sample.new)
     end
-    assert_equal(true, s.include?(strings))
-    assert_equal(true, s.include?(s))
-    assert_equal(false, s.include?('+ a'))
-    assert_equal(false, s.include?('-'))
-    assert_equal(false, s.include?('+ a b a'))
-  end
-  
-  # Tests Sample#include? on every kind of arguments it announce
-  def test_include_accepts_arguments_it_annouce
-    s = Sample.new << ['+ a b a b', '+ a b', '- a', '+']
-    assert_equal true, s.include?('+ a b a b')
-    assert_equal true, s.include?(InputString.new('a b a b',true))
-    assert_equal true, s.include?(ADL::parse_string('+ a b a b'))
-    assert_equal true, s.include?(['+ a b a b', '+ a b'])
-    assert_equal true, s.include?(s)
-  end
-  
-  # Tests Sample#==
-  def test_equal
-    s1 = Sample['+ a b a b', '+', '- a']
-    s2 = Sample['+ a b a b', '+', '+ a']
-    assert_equal(true, s1==s1)
-    assert_equal(true, s2==s2)
-    assert_equal(false, s1==s2)
-    assert_equal(false, s1==Sample.new)
-    assert_equal(false, s2==Sample.new)
-  end
-  
-  # Test the signature
-  def test_signature
-    s = Sample.new
-    assert_equal '', s.signature
-    s = Sample.new << ['+ a b a b', '+ a b', '- a', '+']
-    assert_equal '1101', s.signature
-    s = Sample.new << ['+ a b a b', '+ a b', '- a', '?']
-    assert_equal '110?', s.signature
-    s = Stamina::ADL.parse_sample <<-SAMPLE
-      +
-      + a b
-      - a c
-      ? a d
-    SAMPLE
-    assert_equal '110?', s.signature
-  end
-  
-end # class SampleTest
-    
-end # module Stamina
+    
+    # Test the signature
+    def test_signature
+      s = Sample.new
+      assert_equal '', s.signature
+      s = Sample.new << ['+ a b a b', '+ a b', '- a', '+']
+      assert_equal '1101', s.signature
+      s = Sample.new << ['+ a b a b', '+ a b', '- a', '?']
+      assert_equal '110?', s.signature
+      s = Stamina::ADL.parse_sample <<-SAMPLE
+        +
+        + a b
+        - a c
+        ? a d
+      SAMPLE
+      assert_equal '110?', s.signature
+    end
+    
+  end # class SampleTest
+end # module Stamina

data/test/stamina/scoring_test.rb

@@ -0,0 +1,63 @@
+require 'test/unit'
+require 'stamina/errors'
+require 'stamina/stamina_test'
+require 'stamina/scoring'
+module Stamina
+  class ScoringTest < StaminaTest
+
+    def assert_almost_equal(x, y)
+      assert (x.to_f - y.to_f).abs <= 0.0001
+    end
+
+    def test_scoring_on_exact
+      learned, reference = "11010", "11010"
+      scoring = Scoring.scoring(learned, reference)
+
+      # It looks like a Scoring object
+      assert scoring.respond_to?(:false_positive)
+      assert scoring.respond_to?(:recall)
+
+      # four measures are ok
+      assert_equal 3, scoring.true_positive
+      assert_equal 2, scoring.true_negative
+      assert_equal 0, scoring.false_positive
+      assert_equal 0, scoring.false_negative
+      
+      # precision and recall are ok
+      assert_equal (3.0 / (3.0 + 0.0)), scoring.precision
+      assert_equal (3.0 / (3.0 + 0.0)), scoring.recall
+
+      # sensitivity and specificity are ok
+      assert_equal (3.0 / (3.0 + 0.0)), scoring.sensitivity
+      assert_equal (3.0 / (3.0 + 0.0)), scoring.specificity
+
+      # 
+      assert_equal 1.0, scoring.accuracy
+      assert_equal 1.0, scoring.bcr
+      assert_equal 1.0, scoring.f_measure
+      assert_equal 1.0, scoring.hbcr
+    end
+
+    def test_on_wikipedia_example
+      hash = {
+        :true_positive  => 2,
+        :false_positive => 18,
+        :true_negative  => 182,
+        :false_negative => 1
+      }
+      hash.extend(Scoring)
+      assert_equal (2.0 / (2 + 18)), hash.positive_predictive_value
+      assert_equal (182.0 / (1 + 182)), hash.negative_predictive_value
+      assert_equal (2.0 / (2 + 1)), hash.sensitivity
+      assert_equal (182.0 / (18 + 182)), hash.specificity
+      assert_equal (18.0 / (18 + 182)), hash.false_positive_rate
+      assert_equal (1.0 / (2 + 1)), hash.false_negative_rate
+      #
+      assert_almost_equal (1.0 - hash.specificity), hash.false_positive_rate
+      assert_almost_equal (1.0 - hash.sensitivity), hash.false_negative_rate
+      assert_almost_equal hash.sensitivity / (1.0 - hash.specificity), hash.positive_likelihood
+      assert_almost_equal (1.0 - hash.sensitivity) / hash.specificity, hash.negative_likelihood
+    end
+
+  end # class ScoringTest
+end # module Stamina

data/test/stamina/utils/decorate_test.rb

@@ -0,0 +1,65 @@
+require 'stamina'
+require 'stamina/utils/decorate'
+require 'stamina/stamina_test'
+require 'test/unit'
+module Stamina
+  module Utils
+    class DecorateTest < ::Stamina::StaminaTest
+      
+      module Reachability
+        def suppremum(d0, d1) d0 || d1; end
+        def propagate(deco, edge) deco; end
+      end
+      
+      module Depth
+        def suppremum(d0, d1) (d0 < d1 ? d0 : d1) end
+        def propagate(deco, edge) deco+1; end
+      end
+      
+      module ShortPrefix
+        def suppremum(d0, d1) 
+          return d0 if d1.nil?
+          return d1 if d0.nil?
+          d0.size <= d1.size ? d0 : d1
+        end
+        def propagate(deco, edge) 
+          deco.dup << edge.symbol
+        end
+      end
+      
+      def test_reachability_on_small_dfa
+        algo = Stamina::Utils::Decorate.new(:reachable)
+        algo.set_suppremum {|d0,d1|  d0 || d1 }
+        algo.set_propagate {|deco,edge| deco }
+        algo.execute(@small_dfa, false, true)
+        assert_equal @small_dfa.states.select {|s| s[:reachable]==true}, @small_dfa.states
+        
+        algo = Stamina::Utils::Decorate.new(:reachable)
+        algo.extend(Reachability)
+        algo.execute(@small_dfa, false, true)
+        assert_equal @small_dfa.states.select {|s| s[:reachable]==true}, @small_dfa.states
+      end
+      
+      def test_depth_on_small_dfa
+        algo = Stamina::Utils::Decorate.new(:depth)
+        algo.extend(Depth)
+        algo.execute(@small_dfa, 1000000, 0)
+        assert_equal 0, @small_dfa.ith_state(3)[:depth]
+        assert_equal 1, @small_dfa.ith_state(2)[:depth]
+        assert_equal 2, @small_dfa.ith_state(0)[:depth]
+        assert_equal 3, @small_dfa.ith_state(1)[:depth]
+      end
+      
+      def test_depth_on_small_dfa
+        algo = Stamina::Utils::Decorate.new(:short_prefix)
+        algo.extend(ShortPrefix)
+        algo.execute(@small_dfa, nil, [])
+        assert_equal [], @small_dfa.ith_state(3)[:short_prefix]
+        assert_equal ['b'], @small_dfa.ith_state(2)[:short_prefix]
+        assert_equal ['b', 'c'], @small_dfa.ith_state(0)[:short_prefix]
+        assert_equal ['b', 'c', 'a'], @small_dfa.ith_state(1)[:short_prefix]
+      end
+      
+    end
+  end
+end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: stamina
 version: !ruby/object:Gem::Version 
-  hash: 19
+  hash: 17
   prerelease: 
   segments: 
   - 0
   - 3
-  - 0
-  version: 0.3.0
+  - 1
+  version: 0.3.1
 platform: ruby
 authors: 
 - Bernard Lambeau
@@ -144,6 +144,7 @@ files:
 - lib/stamina/adl.rb
 - lib/stamina/automaton.rb
 - lib/stamina/automaton/walking.rb
+- lib/stamina/automaton/metrics.rb
 - lib/stamina/classifier.rb
 - lib/stamina/command/adl2dot_command.rb
 - lib/stamina/command/classify_command.rb
@@ -160,6 +161,9 @@ files:
 - lib/stamina/sample.rb
 - lib/stamina/version.rb
 - lib/stamina/loader.rb
+- lib/stamina/scoring.rb
+- lib/stamina/utils/decorate.rb
+- lib/stamina/utils.rb
 - tasks/yard.rake
 - tasks/debug_mail.txt
 - tasks/gem.rake
@@ -168,10 +172,8 @@ files:
 - tasks/spec_test.rake
 - test/stamina/adl_test.rb
 - test/stamina/automaton_additional_test.rb
-- test/stamina/automaton_classifier_test.rb
 - test/stamina/automaton_test.rb
-- test/stamina/automaton_to_dot_test.rb
-- test/stamina/automaton_walking_test.rb
+- test/stamina/scoring_test.rb
 - test/stamina/exit.rb
 - test/stamina/induction/induction_test.rb
 - test/stamina/induction/redblue_mergesamestatebug_expected.adl
@@ -198,6 +200,11 @@ files:
 - test/stamina/small_nfa.dot
 - test/stamina/small_nfa.gif
 - test/stamina/stamina_test.rb
+- test/stamina/utils/decorate_test.rb
+- test/stamina/automaton/classifier_test.rb
+- test/stamina/automaton/walking_test.rb
+- test/stamina/automaton/to_dot_test.rb
+- test/stamina/automaton/metrics_test.rb
 - test/test_all.rb
 - .gemtest
 - CHANGELOG.md
@@ -246,10 +253,8 @@ summary: Automaton and Regular Inference Toolkit
 test_files: 
 - test/stamina/adl_test.rb
 - test/stamina/automaton_additional_test.rb
-- test/stamina/automaton_classifier_test.rb
 - test/stamina/automaton_test.rb
-- test/stamina/automaton_to_dot_test.rb
-- test/stamina/automaton_walking_test.rb
+- test/stamina/scoring_test.rb
 - test/stamina/exit.rb
 - test/stamina/induction/induction_test.rb
 - test/stamina/induction/redblue_mergesamestatebug_expected.adl
@@ -276,4 +281,9 @@ test_files:
 - test/stamina/small_nfa.dot
 - test/stamina/small_nfa.gif
 - test/stamina/stamina_test.rb
+- test/stamina/utils/decorate_test.rb
+- test/stamina/automaton/classifier_test.rb
+- test/stamina/automaton/walking_test.rb
+- test/stamina/automaton/to_dot_test.rb
+- test/stamina/automaton/metrics_test.rb
 - test/test_all.rb