shalmaneser-fred 1.2.0.rc4

data/lib/fred/fred.rb

@@ -0,0 +1,47 @@
+# AB: 2011-11-13
+# Initial import done, need to reimplement the whole interface.
+require 'fred/FredFeaturize'
+require 'fred/FredSplit'
+require 'fred/FredTrain'
+require 'fred/FredTest'
+require 'fred/FredEval'
+
+module Fred
+  class Fred
+
+    def initialize(options)
+      @exp, @opts = options
+      @task = @opts['--task']
+    end
+    ##
+    # now perform the given task
+
+    def assign
+
+      # initialize task object
+      case @task
+      when "featurize"
+        task_obj = FredFeaturize.new(@exp, @opts)
+      when "refeaturize"
+        task_obj = FredFeaturize.new(@exp, @opts, "refeaturize" => true)
+      when "split"
+        task_obj = FredSplit.new(@exp, @opts)
+      when "train"
+        task_obj = FredTrain.new(@exp, @opts)
+      when "test"
+        task_obj = FredTest.new(@exp, @opts)
+      when "eval"
+        task_obj = FredEval.new(@exp, @opts)
+      else
+        raise "Shouldn't be here"
+        # @todo AB: this <else> condition should be unpossible
+        #     do in OptionParser
+      end
+      
+      task_obj.compute
+      
+      $stderr.puts "Fred: Done."
+      
+    end
+  end # class Fred
+end # module Fred

data/lib/fred/fred_config_data.rb

@@ -0,0 +1,185 @@
+# FredConfigData
+# Katrin Erk April 05
+#
+# Frame disambiguation system: 
+# access to a configuration and experiment description file
+
+require "common/config_data"
+
+##############################
+# Class FredConfigData
+#
+# inherits from ConfigData,
+# sets variable names appropriate to WSD task
+
+class FredConfigData < ConfigData
+  CONFIG_DEFS = { 
+    "experiment_ID" => "string", # experiment ID
+    "enduser_mode" => "bool", # work in enduser mode? (disallowing many things)
+    
+    "preproc_descr_file_train" => "string", # path to preprocessing files
+    "preproc_descr_file_test" => "string",
+    "directory_output" => "string", # path to Salsa/Tiger XML output directory
+    
+    "verbose" => "bool" ,     # print diagnostic messages?
+    "apply_to_all_known_targets" => "bool", # apply to all known targets rather than the ones with a frame?
+    
+    "fred_directory" => "string",# directory for internal info
+    "classifier_dir" => "string", # write classifiers here
+    
+    "classifier" => "list",  # classifiers
+    
+    "dbtype" => "string",    # "mysql" or "sqlite"
+    
+    "host" => "string",      # DB access: sqlite only
+    "user" => "string",
+    "passwd" => "string",
+    "dbname" => "string",
+    
+    # featurization info
+    "feature" => "list",     # which features to use for the classifier?
+    "binary_classifiers" => "bool",# make binary rather than n-ary clasifiers?
+    "negsense" => "string",  # binary classifier: negative sense is..?
+    "numerical_features" => "string", # do what with numerical features?
+    
+    # what to do with items that have multiple senses?
+    # 'binarize': binary classifiers, and consider positive
+    #          if the sense is among the gold senses
+    # 'join' : make one joint sense
+    # 'repeat' : make multiple occurrences of the item, one sense per occ
+    # 'keep' : keep as separate labels
+    #
+    # multilabel: consider as assigned all labels
+    # above a certain confidence threshold?
+    "handle_multilabel" => "string",
+    "assignment_confidence_threshold" => "float",
+    
+    # single-sentence context?
+    "single_sent_context" => "bool",
+    
+    # noncontiguous input? then we need access to a larger corpus
+    "noncontiguous_input" => "bool",
+    "larger_corpus_dir" => "string",
+    "larger_corpus_format" => "string", 
+    "larger_corpus_encoding" => "string",
+    # Imported from PrepConfigData
+    'do_postag' => 'bool',
+    'do_lemmatize' => 'bool',
+    'do_parse' => 'bool',
+    'pos_tagger' => 'string',
+    'lemmatizer' => 'string',
+    'parser' => 'string',
+    'directory_preprocessed' => 'string',
+    'language' => 'string'
+  }
+
+  def initialize(filename)
+
+    super(filename, CONFIG_DEFS, ["train", "exp_ID"])
+
+    # set access functions for list features
+    set_list_feature_access("classifier", method("access_classifier"))
+    set_list_feature_access("feature", method("access_feature"))
+  end
+
+  ###
+  # protected
+
+  #####
+  # access_feature
+  # 
+  # access function for feature 'feature'
+  #
+  # assumed format:
+  #
+  #   feature = context 50
+  #   feature = context 2
+  #   feature = syn
+  #
+  # i.e. first the name of the feature type to use, then
+  # optionally a parameter,
+  # and the same feature can occur more than once (which makes sense
+  # only in case of parameters)
+  #
+  #
+  # returns: 
+  #  - If a feature is given as a parameter, 
+  #    - If the feature is not set in the experiment file, nil
+  #    - If the feature is set and has a parameter, the list of 
+  #      parameter values set for it. It is assumed that the parameters
+  #      are integers, and they are returned as integers
+  #    - If the feature is set and has no parameter, true
+  # - If no feature is given as parameter:
+  #   a list of all features that have been set in the experiment file
+  #   Each feature is given as a tuple: the first element is the feature (a string),
+  #   all further elements are options (integers)
+  def access_feature(val_list, # array:array:string: list of tuples defined in config file
+		               # for feature 'feature'
+		     feature=nil)  # string: feature type name
+
+    if feature
+      # access options for this feature
+
+      # get the right tuples
+      positives = val_list.select { |entries|
+        entries.first() == feature
+      }.map { |entries|
+        entries[1]
+      }
+      
+      if positives.empty?
+        # feature not defined
+        return nil
+        
+      elsif positives.compact().empty?
+        # feature defined, but no parameters
+        return true
+        
+      else
+        # feature defined, and has values
+        return positives.map { |par| par.to_i() }
+      end
+
+    else
+      # return all features that have been set
+      return val_list.map { |feature_name, *options|
+        [feature_name] + options.map { |o| o.to_i() }        
+      }
+    end
+  end
+
+  #####
+  # access_classifier
+  #
+  # access function for feature 'classifier'
+  #
+  # assumed format in the config file:
+  #
+  #   feature = path [option]*
+  #
+  # i.e. first the name of the feature type to use, then
+  # optionally options associated with that feature,
+  # e.g. 'argrec': use that feature only when computing argrec
+  #
+  # the access function is called with parameter val_list, an array of
+  # string tuples, one string tuple for each feature defined.
+  # the first string in the tuple is the feature name, the rest are the options
+  #
+  # returns: a list of pairs [feature_name(string), options(array:string)]
+  # of defined features
+  # @param val_list [Array] array:array:string: list of tuples defined
+  #   in config file for feature 'feature'
+  def access_classifier(val_list)
+    if val_list.nil?
+      []
+    else
+      val_list.map do |cl_descr_tuple|
+        [cl_descr_tuple.first, cl_descr_tuple[1..-1]]
+      end
+    end
+  end
+
+end
+
+
+ 

data/lib/fred/md5.rb

@@ -0,0 +1,23 @@
+# just for compatibility; requiring "md5" is obsoleted
+#
+# $RoughId: md5.rb,v 1.4 2001/07/13 15:38:27 knu Exp $
+# $Id: md5.rb 12008 2007-03-06 10:12:12Z knu $
+
+require 'digest/md5'
+
+class MD5 < Digest::MD5
+  class << self
+    alias orig_new new
+    def new(str = nil)
+      if str
+        orig_new.update(str)
+      else
+        orig_new
+      end
+    end
+
+    def md5(*args)
+      new(*args)
+    end
+  end
+end

data/lib/fred/opt_parser.rb

@@ -0,0 +1,250 @@
+# -*- encoding: utf-8 -*-
+
+# AB, 2011-11-13
+
+#require 'optparse' # for reimplementation
+require 'getoptlong'
+require "fred/fred_config_data"
+
+module Fred
+
+  # This class parses options for Fred.
+  class OptParser
+    def self.parse(cmd_opts)
+      tasks = {
+        "featurize" => [ [ '--dataset', '-d', GetoptLong::REQUIRED_ARGUMENT], # set to featurize: 'train' or 'test'
+                         [ "--append", "-A", GetoptLong::NO_ARGUMENT]
+                       ],
+        "refeaturize" => [ [ '--dataset', '-d', GetoptLong::REQUIRED_ARGUMENT], # set to featurize: 'train' or 'test'
+                           [ "--append", "-A", GetoptLong::NO_ARGUMENT]
+                         ],
+        "split" => [ ['--logID', '-i', GetoptLong::REQUIRED_ARGUMENT],  # splitlog ID, required, no default
+                     [ '--trainpercent', '-r', GetoptLong::REQUIRED_ARGUMENT]      # percentage training data, default: 90
+                   ],
+        "train" => [ ['--logID', '-i', GetoptLong::REQUIRED_ARGUMENT]  # splitlog ID; if given, will train on split
+                     # rather than all training data
+                   ],
+        "test" => [ ['--logID', '-i', GetoptLong::REQUIRED_ARGUMENT],   # splitlog ID: if given, test on this split of 
+                    # the training data
+                    [ '--baseline', '-b', GetoptLong::NO_ARGUMENT],                # set this to compute baseline rather than
+                    # apply classifiers
+                    [ '--nooutput', '-N', GetoptLong::NO_ARGUMENT]               # set this to prevent output of disambiguated
+                    # test data
+                    
+                  ],
+        "eval" => [['--logID', '-i', GetoptLong::REQUIRED_ARGUMENT],    # splitlog ID: if given, evaluate this split. 
+                   ['--printLog', '-l', GetoptLong::NO_ARGUMENT]
+                  ]
+      }
+      
+      # general options
+      optnames = [[ '--help', '-h', GetoptLong::NO_ARGUMENT],            # get help
+                  [ '--expfile', '-e', GetoptLong::REQUIRED_ARGUMENT],             # experiment file name (and path), no default
+                  [ '--task', '-t', GetoptLong::REQUIRED_ARGUMENT ],               # task to perform: one of task.keys, no default
+                 ]
+      # append task-specific to general options
+      tasks.values.each { |more_optnames|
+        optnames.concat more_optnames
+      }
+      optnames.uniq!
+      
+      # asterisk: "explode" array into individual parameters
+      begin
+        opts = options_hash(GetoptLong.new(*optnames))
+      rescue
+        $stderr.puts "Error: unknown command line option: " + $!
+        exit 1
+      end
+      
+      experiment_filename = nil
+      
+      ##
+      # are we being asked for help?
+      if opts['--help']
+        help()
+        exit(0)
+      end
+      
+      ##
+      # now find the task
+      task = opts['--task']
+      # sanity checks for task
+      if task.nil?
+        help()
+        exit(0)
+      end
+      unless tasks.keys.include? task
+        $stderr.puts "Sorry, I don't know the task " + task
+        exit 1
+      end
+      
+      ##
+      # now evaluate the rest of the options
+      opts.each_pair { |opt,arg|
+        case opt
+        when '--help', '--task'
+          # we already handled this
+        when '--expfile'
+          experiment_filename = arg
+        else
+          # do we know this option?
+          unless tasks[task].assoc(opt)
+            $stderr.puts "Sorry, I don't know the option " + opt + " for task " + task
+            exit 1
+          end
+        end
+      }
+      
+      
+      
+      unless experiment_filename
+        $stderr.puts "I need an experiment file name, option --expfile|-e"
+        exit 1
+      end
+      
+      ##
+      # open config file
+      
+      exp = FredConfigData.new(experiment_filename)
+      
+      # sanity checks
+      unless exp.get("experiment_ID") =~ /^[A-Za-z0-9_]+$/
+        raise "Please choose an experiment ID consisting only of the letters A-Za-z0-9_."
+      end
+      
+      # enduser mode?
+      $ENDUSER_MODE = exp.get("enduser_mode") 
+      
+      # set defaults
+      unless exp.get("handle_multilabel")
+        if exp.get("binary_classifiers")
+          exp.set_entry("handle_multilabel", "binarize")
+        else
+          exp.set_entry("handle_multilabel", "repeat")
+        end
+      end
+      # sanity check: if we're using option 'binarize' for handling items
+      # with multiple labels, we have to have binary classifiers
+      if exp.get("handle_multilabel") == "binarize" and not(exp.get("binary_classifiers"))
+        $stderr.puts "Error: cannot use 'handle_multilabel=binarize' with n-ary classifiers."
+        exit(1)
+      end
+      unless exp.get("numerical_features")
+        exp.set_entry("numerical_features", "bin")
+      end
+
+      [exp, opts]
+    end
+    private
+    ###
+    # options_hash:
+    #
+    # GetoptLong only allows you to access options via each(),
+    # not individually, and it only allows you to cycle through the options once.
+    # So we re-code the options as a hash
+    def self.options_hash(opts_obj) # GetoptLong object
+      opt_hash = Hash.new
+      
+      opts_obj.each do |opt, arg|
+        opt_hash[opt] = arg
+      end
+      
+      return opt_hash
+    end
+    def self.help
+        $stderr.puts "
+Fred: FRamE Disambiguation System Version 0.3
+  
+Usage:
+----------------
+
+ruby fred.rb --help|-h
+  Gets you this text.
+
+
+ruby fred.rb --task|-t featurize --expfile|-e <e> --dataset|-d <d> 
+        [--append|-A]
+  Featurizes input data and stores it in feature files.
+  Feature files are stored in 
+  <fred_directory>/<experiment_ID>/<train/test>/features
+  Enduser mode: dataset has to be test (preset as default), no --append.
+
+  --expfile <e> Use <e> as the experiment description and configuation file
+
+  --dataset <d> Set to featurize: <d> is either 'train' or 'test'
+                Accordingly, either the directory dir_train or dir_test (as 
+                specified in the experiment file) is used to store the features
+
+  --append      Do not overwrite previously computed features for this experiment.
+                Rather, append the new features to the old featurization files.
+                Default: overwrite
+
+ruby fred.rb --task|-t split --expfile|-e <e> --logID|-i <i> 
+             [--trainpercent|-r <r>]
+  Produces a new train/test split on the training data of the experiment.
+  Split logs are stored in <fred_directory>/<experiment_ID>/split/<splitlog ID>
+  Not available in enduser mode.
+
+  --expfile <e> Use <e> as the experiment description and configuation file
+
+  --logID <l>   Use <l> as the ID for storing this new split
+
+  --trainpercent <r> Allocate <r> percent of the data as train, 
+                and 100-<r> as test.
+                default: <r>=90
+     
+ruby fred.rb --task|-t train --expfile|-e <e>  
+             [--logID|-i <i> ]
+  Train classifier(s) on the training data (or a split of it)
+  Classifiers are stored in 
+  <fred_directory>/<experiment_ID>/classifiers/<classifier_name>
+  Not available in enduser mode.
+
+  --expfile <e> Use <e> as the experiment description and configuation file
+
+  --logID <l>   Train not on the whole training data but 
+                on the split with ID <l>
+
+ruby fred.rb --task|-t test --expfile|-e <e>  
+             [--logID|-i <i>] [--baseline|-b]
+             [--nooutput|-N]
+  Apply classifier(s) to the test data (or a split of the training data)
+  Classification results are stored in 
+  <fred_directory>/<experiment_ID>/results/main or
+  <fred_directory>/<experiment_ID>/results/baseline for the baseline.
+  If you are using classifier combination, individual classification results
+  are stored in <fred_directory>/<experiment_ID>/results/<classifier_name>
+  System output (disambiguated text in SalsaTigerXML format) is stored in
+  <fred_directory>/<experiment_ID>/output/stxml
+  or <directory_output>, if that has been specified.
+
+  --expfile <e> Use <e> as the experiment description and configuation file
+
+  --logID <l>   Test on a split of the training data with ID <l>
+
+  --baseline    Compute the baseline: Always assign most frequent sense.
+                Default: use the trained classifiers
+
+  --nooutput    Do not produce an output of the disambiguated test data 
+                in SalsaTigerXML format. This is useful if you just want
+                to evaluate the system.
+                Default: output is produced.
+
+ ruby fred.rb --task|-t eval --expfile|-e <e>  
+              [--logID|-i <i>] [--printLog|-l]
+  Evaluate the performance of Fred on the test data 
+  (or on a split of the training data).
+  Evaluation file is written to <fred_directory>/<experiment_ID>/eval/eval
+  Not available in enduser mode.
+
+  --expfile <e> Use <e> as the experiment description and configuation file
+
+  --logID <l>   Evaluate a split of the training data with ID <l>
+
+  --printLog    Also print logfile detailing evaluation of every instance.
+                Log file is written to <fred_directory>/eval/log
+
+"
+    end
+  end # class OptParser
+end # module FrPrep