stamina 0.4.0 → 0.5.0

data/lib/stamina/classifier.rb

@@ -1,52 +0,0 @@
-module Stamina
-  #
-  # Provides a reusable module for binary classifiers. Classes including this
-  # module are required to provide a label_of(string) method, returning '1' for
-  # strings considered positive, and '0' fr strings considered negative.
-  #
-  # Note that an Automaton being a classifier it already includes this module.
-  #
-  module Classifier
-    
-    #
-    # Computes a signature for a given sample (that is, an ordered set of strings).
-    # The signature is a string containing 1 (considered positive, or accepted) 
-    # and 0 (considered negative, or rejected), one for each string.
-    #
-    def signature(sample)
-      signature = ''
-      sample.each do |str|
-        signature << label_of(str)
-      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.
-    #
-    def correctly_classify?(sample)
-      sample.each do |str|
-        label = label_of(str)
-        expected = (str.positive? ? '1' : '0')
-        return false unless expected==label
-      end
-      true
-    end
-    
-  end # module Classifier
-end # module Stamina

data/lib/stamina/command.rb

@@ -1,45 +0,0 @@
-require 'stamina'
-module Stamina
-  #
-  # Stamina - A Ruby Automaton & Induction Toolkit
-  #
-  # SYNOPSIS
-  #   #{program_name} [--version] [--help] COMMAND [cmd opts] ARGS...
-  #
-  # OPTIONS
-  # #{summarized_options}
-  #
-  # COMMANDS
-  # #{summarized_subcommands}
-  #
-  # See '#{program_name} help COMMAND' for more information on a specific command.
-  #
-  class Command < ::Quickl::Delegator(__FILE__, __LINE__)
-
-    # Install options
-    options do |opt|
-      
-      # Show the help and exit
-      opt.on_tail("--help", "Show help") do
-        raise Quickl::Help
-      end
-
-      # Show version and exit
-      opt.on_tail("--version", "Show version") do
-        raise Quickl::Exit, "#{program_name} #{VERSION} (c) 2010-2011, Bernard Lambeau"
-      end
-
-    end
-
-  end # class Command
-end # module Stamina
-require 'stamina/command/robustness'
-require 'stamina/command/help'
-require 'stamina/command/adl2dot'
-require 'stamina/command/metrics'
-require 'stamina/command/classify'
-require 'stamina/command/score'
-require 'stamina/command/abbadingo_dfa'
-require 'stamina/command/abbadingo_samples'
-require 'stamina/command/infer'
-

data/lib/stamina/command/abbadingo_dfa.rb

@@ -1,81 +0,0 @@
-module Stamina
-  class Command
-    # 
-    # Generates a DFA following Abbadingo's protocol
-    #
-    # SYNOPSIS
-    #   #{program_name} #{command_name}
-    #
-    # OPTIONS
-    # #{summarized_options}
-    #
-    class AbbadingoDfa < Quickl::Command(__FILE__, __LINE__)
-      include Robustness 
-
-      # Size of the target automaton
-      attr_accessor :size
-
-      # Tolerance on the size
-      attr_accessor :size_tolerance
-
-      # Tolerance on the automaton depth
-      attr_accessor :depth_tolerance
-
-      # Where to flush the dfa
-      attr_accessor :output_file
-
-      # Install options
-      options do |opt|
-      
-        @size = 64
-        opt.on("--size=X", Integer, "Sets the size of the automaton to generate") do |x|
-          @size = x
-        end
-
-        @size_tolerance = nil
-        opt.on("--size-tolerance[=X]", Integer, "Sets the tolerance on automaton size (in number of states)") do |x|
-          @size_tolerance = x
-        end
-
-        @depth_tolerance = 0
-        opt.on("--depth-tolerance[=X]", Integer, "Sets the tolerance on expected automaton depth (in length, 0 by default)") do |x|
-          @depth_tolerance = x
-        end
-
-        @output_file = nil
-        opt.on("-o", "--output=OUTPUT",
-               "Flush DFA in output file") do |value|
-          @output_file = assert_writable_file(value)
-        end
-
-      end # options
-
-      def accept?(dfa)
-        (size_tolerance.nil?  || (size - dfa.state_count).abs <= size_tolerance) &&
-        (depth_tolerance.nil? || ((2*Math.log2(size)-2) - dfa.depth).abs <= depth_tolerance)
-      end
-
-      # Command execution
-      def execute(args)
-        require 'stamina/abbadingo'
-
-        # generate it
-        randomizer = Stamina::Abbadingo::RandomDFA.new(size)
-        begin
-          dfa = randomizer.execute
-        end until accept?(dfa)
-
-        # flush it
-        if output_file 
-          File.open(output_file, 'w') do |file|
-            Stamina::ADL.print_automaton(dfa, file)
-          end
-        else
-          Stamina::ADL.print_automaton(dfa, $stdout)
-        end
-      end
-      
-    end # class AbbadingoDFA
-  end # class Command
-end # module Stamina
-

data/lib/stamina/command/abbadingo_samples.rb

@@ -1,40 +0,0 @@
-module Stamina
-  class Command
-    # 
-    # Generates samples following Abbadingo's protocol
-    #
-    # SYNOPSIS
-    #   #{program_name} #{command_name} target.adl
-    #
-    # OPTIONS
-    # #{summarized_options}
-    #
-    class AbbadingoSamples < Quickl::Command(__FILE__, __LINE__)
-      
-      # Install options
-      options do |opt|
-      
-      end # options
-
-      # Command execution
-      def execute(args)
-        raise Quickl::Help unless args.size == 1
-
-        # Loads the target automaton
-        target_file = args.first
-        basename = File.basename(target_file, '.adl')
-        dirname = File.dirname(target_file)
-        target = Stamina::ADL::parse_automaton_file(target_file)
-
-        require 'stamina/abbadingo'
-        training, test = Stamina::Abbadingo::RandomSample.execute(target)
-
-        # Flush results aside the target automaton file
-        Stamina::ADL::print_sample_in_file(training, File.join(dirname, "#{basename}-training.adl"))
-        Stamina::ADL::print_sample_in_file(test,     File.join(dirname, "#{basename}-test.adl"))
-      end
-      
-    end # class AbbadingoSamples
-  end # class Command
-end # module Stamina
-

data/lib/stamina/command/adl2dot.rb

@@ -1,71 +0,0 @@
-module Stamina
-  class Command
-    # 
-    # Prints an automaton expressed in ADL in dot (or gif) format
-    #
-    # SYNOPSIS
-    #   #{program_name} #{command_name} automaton.adl
-    #
-    # OPTIONS
-    # #{summarized_options}
-    #
-    class Adl2dot < Quickl::Command(__FILE__, __LINE__)
-      include Robustness
-      
-      attr_reader :gif_output
-
-      # Install options
-      options do |opt|
-      
-        @output_file = nil
-        opt.on("-o", "--output=OUTPUT",
-               "Flush result output file") do |value|
-          @output_file = assert_writable_file(value)
-        end
-
-        opt.on("-g", "--gif",
-               "Generates a gif file instead of a dot one") do
-          @gif_output = true
-        end
-
-      end # options
-
-      def output_file(infile)
-        @output_file || "#{File.basename(infile || 'stdin.adl', '.adl')}.#{gif_output ? 'gif' : 'dot'}"
-      end
-
-      # Command execution
-      def execute(args)
-        raise Quickl::Help unless args.size <= 1
-
-        # Loads the target automaton
-        input = if args.size == 1
-          File.read assert_readable_file(args.first)
-        else
-          $stdin.readlines.join("\n")
-        end
-        automaton = Stamina::ADL::parse_automaton(input)
-
-        # create a file for the dot output
-        if gif_output
-          require 'tempfile'
-          dotfile = Tempfile.new("stamina").path
-        else
-          dotfile = output_file(args.first)
-        end
-        
-        # Flush automaton inside it
-        File.open(dotfile, 'w') do |f|
-          f << automaton.to_dot
-        end
-        
-        # if gif output, use dot to convert it
-        if gif_output
-          `dot -Tgif -o #{output_file(args.first)} #{dotfile}` 
-        end
-      end
-      
-    end # class Adl2dot
-  end # class Command
-end # module Stamina
-

data/lib/stamina/command/classify.rb

@@ -1,48 +0,0 @@
-module Stamina
-  class Command
-    # 
-    # Classifies a sample thanks with an automaton
-    #
-    # SYNOPSIS
-    #   #{program_name} #{command_name} sample.adl automaton.adl
-    #
-    # OPTIONS
-    # #{summarized_options}
-    #
-    class Classify < Quickl::Command(__FILE__, __LINE__)
-      include Robustness
-
-      # Where to flush the output
-      attr_accessor :output_file
-
-      # Install options
-      options do |opt|
-
-        @output_file = nil
-        opt.on("-o", "--output=OUTPUT",
-               "Flush classification signature in output file") do |value|
-          assert_writable_file(value)
-          @output_file = value
-        end
-      
-      end # options
-
-      # Command execution
-      def execute(args)
-        raise Quickl::Help unless args.size == 2
-        sample    = Stamina::ADL::parse_sample_file assert_readable_file(args.first)
-        automaton = Stamina::ADL::parse_automaton_file assert_readable_file(args.last)
-
-        if of = output_file
-          File.open(of, 'w'){|io| 
-            io << automaton.signature(sample)
-          }
-        else
-          $stdout << automaton.signature(sample)
-        end
-      end
-      
-    end # class Classify
-  end # class Command
-end # module Stamina
-

data/lib/stamina/command/help.rb

@@ -1,27 +0,0 @@
-module Stamina
-  class Command
-    # 
-    # Show help about a specific command
-    #
-    # SYNOPSIS
-    #   #{program_name} #{command_name} COMMAND
-    #
-    class Help < Quickl::Command(__FILE__, __LINE__)
-      
-      # Let NoSuchCommandError be passed to higher stage
-      no_react_to Quickl::NoSuchCommand
-      
-      # Command execution
-      def execute(args)
-        if args.size != 1
-          puts super_command.help
-        else
-          cmd = has_command!(args.first, super_command)
-          puts cmd.help
-        end
-      end
-      
-    end # class Help
-  end # class Command
-end # module Stamina
-

data/lib/stamina/command/infer.rb

@@ -1,141 +0,0 @@
-module Stamina
-  class Command
-    # 
-    # Grammar inference, induces a DFA from a training sample using an 
-    # chosen algorithm.
-    #
-    # SYNOPSIS
-    #   #{program_name} #{command_name} sample.adl
-    #
-    # OPTIONS
-    # #{summarized_options}
-    #
-    class Infer < Quickl::Command(__FILE__, __LINE__)
-      include Robustness
-      
-      attr_accessor :algorithm
-      attr_accessor :take
-      attr_accessor :score
-      attr_accessor :verbose
-      attr_accessor :drop
-      attr_accessor :output_file
-
-      # Install options
-      options do |opt|
-      
-        @algorithm = :rpni
-        opt.on("--algorithm=X", "Sets the induction algorithm to use (rpni, bluefringe)") do |x|
-          @algorithm = x.to_sym
-        end
-
-        @take = 1.0
-        opt.on("--take=X", Float, "Take only X% of available strings") do |x|
-          @take = x.to_f
-          unless @take > 0.0 and @take <= 1.0
-            raise Quickl::InvalidOption, "Invalid --take option: #{@take}"
-          end 
-        end
-
-        @score = nil
-        opt.on("--score=test.adl", "Add scoring information to metadata, using test.adl file") do |x|
-          @score = assert_readable_file(x)
-        end
-
-        @verbose = true
-        opt.on("-v", "--[no-]verbose", "Verbose mode") do |x|
-          @verbose = x
-        end
-
-        @drop = false
-        opt.on("-d", "--drop", "Drop result") do |x|
-          @drop = x
-        end
-
-        @output_file = nil
-        opt.on("-o", "--output=OUTPUT",
-               "Flush induced DFA in output file") do |value|
-          @output_file = assert_writable_file(value)
-        end
-
-      end # options
-
-      def launch_induction(sample)
-        require 'benchmark'
-
-        algo_clazz = case algorithm
-          when :rpni
-            Stamina::Induction::RPNI
-          when :bluefringe
-            Stamina::Induction::BlueFringe
-          else
-            raise Quickl::InvalidOption, "Unknown induction algorithm: #{algo}"
-        end
-
-        dfa, tms = nil, nil
-        tms = Benchmark.measure do 
-          dfa = algo_clazz.execute(sample, {:verbose => verbose})
-        end
-        [dfa, tms]
-      end
-
-      def load_sample(file)
-        sample = Stamina::ADL.parse_sample_file(file)
-        if @take != 1.0
-          sampled = Stamina::Sample.new
-          sample.each_positive{|s| sampled << s if Kernel.rand < @take}
-          sample.each_negative{|s| sampled << s if Kernel.rand < @take}
-          sample = sampled
-        end
-        sample
-      end
-
-      # Command execution
-      def execute(args)
-        raise Quickl::Help unless args.size == 1
-      
-        # Parses the sample
-        $stderr << "Parsing sample...\n" if verbose
-        sample = load_sample(assert_readable_file(args.first))
-
-        # Induce the DFA
-        dfa, tms = launch_induction(sample)
-
-        # Flush result
-        unless drop
-          if output_file 
-            File.open(output_file, 'w') do |file|
-              Stamina::ADL.print_automaton(dfa, file)
-            end
-          else
-            Stamina::ADL.print_automaton(dfa, $stdout)
-          end
-        end
-
-        # build meta information
-        meta = {:algorithm   => algorithm,
-                :sample      => File.basename(args.first),
-                :take        => take,
-                :sample_size => sample.size,
-                :positive_count => sample.positive_count,
-                :negative_count => sample.negative_count,
-                :real_time   => tms.real,
-                :total_time  => tms.total,
-                :user_time   => tms.utime + tms.cutime,
-                :system_time => tms.stime + tms.cstime}
-
-        if score
-          test = Stamina::ADL::parse_sample_file(score)
-          classified_as = dfa.signature(test)
-          reference = test.signature
-          scoring = Scoring.scoring(classified_as, reference)
-          meta.merge!(scoring.to_h)
-        end
-
-        # Display information
-        puts meta.inspect
-      end
-      
-    end # class Infer
-  end # class Command
-end # module Stamina
-