shalmaneser 1.2.0.rc4 → 1.2.rc5

data/lib/fred/FredFeatures.rb

@@ -1,1061 +0,0 @@
-# -*- coding: utf-8 -*-
-require "tempfile"
-require "delegate"
-
-require "fred/FredFeatureExtractors"
-
-########################################
-########################################
-# Feature access classes:
-# read and write features
-class AbstractFredFeatureAccess
-  ####
-  def initialize(exp, # experiment file object
-                 dataset, # dataset: "train" or "test"
-                 mode = "r") # mode: r, w, a
-    @exp = exp
-    @dataset = dataset
-    @mode = mode
-    
-    unless ["r", "w", "a"].include? @mode
-      $stderr.puts "FeatureAccess: unknown mode #{@mode}."
-      exit 1
-    end
-
-  end
-
-  ####
-  def AbstractFredFeatureAccess.remove_feature_files()
-    raise "overwrite me"
-  end
-
-  ####
-  def write_item(lemma,  # string: lemma
-                 pos,    # string: POS
-                 ids,    # array:string: unique IDs of this occurrence of the lemma
-                 sid,    # string: sentence ID
-                 sense,  # string: sense
-                 features) # features: hash feature type-> features (string-> array:string)
-    raise "overwrite me"
-  end
-                 
-
-  def flush()
-    raise "overwrite me"
-  end
-end
-
-########################################
-# MetaFeatureAccess:
-# write all featurization data to one gzipped file,
-# directly writing the meta-features as they come
-# format:
-#
-# lemma pos id sense
-#   <feature_type>: <features>
-#
-# where feature_type is a word, and features is a list of words, space-separated
-class MetaFeatureAccess < AbstractFredFeatureAccess
-  ###
-  def initialize(exp, dataset, mode)
-    super(exp, dataset, mode)
-
-    @filename = MetaFeatureAccess.filename(@exp, @dataset)
-
-    # make filename for writing features
-    case @mode
-
-    when "w", "a", "r"
-      # read or write access
-      @f = FileZipped.new(@filename, mode)
-
-    else
-      $stderr.puts "MetaFeatureAccess error: illegal mode #{mode}"
-      exit 1
-    end
-  end
-
-
-  ####
-  def MetaFeatureAccess.filename(exp, dataset, mode="new")
-    return fred_dirname(exp, dataset, "meta_features", mode) +
-      "meta_features.txt.gz"
-  end
-
-  ####
-  def MetaFeatureAccess.remove_feature_files(exp, dataset)
-    filename = MetaFeatureAccess.filename(exp, dataset)
-    if File.exists?(filename)
-      File.delete(filename)
-    end
-  end
-
-
-  ###
-  # read items, yield one at a time
-  #
-  # format: tuple consisting of
-  # - target_lemma: string
-  # - target_pos: string
-  # - target_ids: array:string
-  # - target SID: string, sentence ID
-  # - target_senses: array:string
-  # - feature_hash: feature_type->values, string->array:string
-  def each_item()
-    unless @mode == "r"
-      $stderr.puts "MetaFeatureAccess error: cannot read file not opened for reading"
-      exit 1
-    end
-
-    lemma = pos = sid = ids = senses = nil
-
-    feature_hash = Hash.new()
-
-    @f.each { |line|
-      line.chomp!
-      if line =~ /^\s/
-        # line starts with whitespace: continues description of previous item
-        # that is, if we have a previous item
-        #
-        # format of line:
-        #    feature_type: feature feature feature ...
-        # as in 
-        #    CH: SB#expansion#expansion#NN# OA#change#change#NN#
-        unless lemma
-          $stderr.puts "MetaFeatureAccess error: unexpected leading whitespace"
-          $stderr.puts "in meta-feature file #{@filename}, ignoring line:"
-          $stderr.puts line
-          next
-        end
-
-        feature_type, *features = line.split()
-        
-        unless feature_type =~ /^(.*):$/
-          # feature type should end in ":"
-          $stderr.puts "MetaFeatureAccess error: feature type should end in ':' but doesn't"
-          $stderr.puts "in meta-feature file #{@filename}, ignoring line:"
-          $stderr.puts line
-          next
-        end
-
-        feature_hash[feature_type[0..-2]] = features
-         
-        
-      else
-        # first line of item.
-        #
-        # format:
-        # lemma POS IDs sid senses
-        # 
-        # as in:
-        # cause verb 2-651966_8 2-651966 Causation
-
-        # first yield previous item
-        if lemma
-          yield [lemma, pos, ids, sid, senses, feature_hash]
-        end
-
-        # then start new item:
-        lemma, pos, ids_s, sid, senses_s = line.split()
-        ids = ids_s.split("::").map { |i| i.gsub(/COLON/, ":") }
-        senses = senses_s.split("::").map { |s| s.gsub(/COLON/, ":") }
-
-        # reset feature hash
-        feature_hash.clear()
-      end
-    }
-
-    # one more item to yield?
-    if lemma
-      yield [lemma, pos, ids, sid, senses, feature_hash]
-    end
-  end
-
-
-
-  ###
-  def write_item(lemma,  # string: target lemma
-                 pos,    # string: target pos
-                 ids,    # array:string: unique IDs of this occurrence of the lemma
-                 sid,    # string: sentence ID
-                 senses, # array:string: sense
-                 features) # features: hash feature type-> features (string-> array:string)
-
-    unless ["w", "a"].include? @mode
-      $stderr.puts "MetaFeatureAccess error: cannot write to feature file opened for reading"
-      exit 1
-    end
-
-    if not(lemma) or lemma.empty? or not(ids) or ids.empty?
-      # nothing to write
-      # HIER debugging
-      # raise "HIER no lemma or no IDs: #{lemma} #{ids}"
-      return
-    end
-    if pos.nil? or pos.empty?
-      # POS unknown
-      pos = ""
-    end
-    unless senses
-      senses = [ @exp.get("noval") ]
-    end
-
-    ids_s = ids.map { |i| i.gsub(/:/, "COLON") }.join("::")
-
-    senses_s = senses.map { |s| s.gsub(/:/, "COLON") }.join("::")
-    @f.puts "#{lemma} #{pos} #{ids_s} #{sid} #{senses_s}"
-    features.each_pair { |feature_type, f_list|
-      @f.puts "   #{feature_type}: " + f_list.map { |f| f.to_s() }.join(" ")
-    }
-    @f.flush()
-  end
-
-  ###
-  def flush()
-    unless ["w", "a"].include? @mode
-      $stderr.puts "MetaFeatureAccess error: cannot write to feature file opened for reading"
-      exit 1
-    end
-
-    # actually, nothing to be done here
-  end
-
-end
-
-
-########################################
-# FredFeatureWriter:
-# write chosen features (according to the experiment file)
-# to
-# - one file per lemma for n-ary classification
-# - one file per lemma/sense pair for binary classification
-#
-# format: CSV, last entry is target class
-class FredFeatureAccess < AbstractFredFeatureAccess
-  ###
-  def initialize(exp, dataset, mode)
-    super(exp, dataset, mode)
-
-    # write to auxiliary files first,
-    # to sort items by lemma
-    @w_tmp = AuxKeepWriters.new()
-
-    # which features has the user requested?
-    feature_info_obj = FredFeatureInfo.new(@exp)
-    @feature_extractors = feature_info_obj.get_extractor_objects()
-
-  end
-
-  ####
-  def FredFeatureAccess.remove_feature_files(exp, dataset)
-    
-    # remove feature files
-    WriteFeaturesNaryOrBinary.remove_files(exp, dataset)
-
-    # remove key files
-    AnswerKeyAccess.remove_files(exp, dataset)
-  end
-  
-  ###
-  def  FredFeatureAccess.legend_filename(lemmapos)
-    return "fred.feature_legend.#{lemmapos}"
-  end
-
-  ### 
-  def FredFeatureAccess.feature_dir(exp, dataset)
-    return WriteFeaturesNaryOrBinary.feature_dir(exp, dataset, "new")
-  end
-
-  ###
-  # each feature file:
-  # iterate through feature files,
-  # yield pairs [filename, values]
-  # where 'values' is a hash containing keys
-  # 'lemma' and potentially 'sense'
-  #
-  # filenames are sorted alphabetically before being yielded
-  #
-  # available in read and write mode
-  def FredFeatureAccess.each_feature_file(exp, dataset)
-    feature_dir = FredFeatureAccess.feature_dir(exp, dataset)
-    Dir[feature_dir + "*"].sort().each { |filename|
-      if (values = deconstruct_fred_feature_filename(filename))
-        yield [filename, values]
-      end
-    }
-  end
-
-  ###
-  # write item: 
-  # - transform meta-features into actual features as requested
-  #   in the experiment file
-  # - write item to tempfile, don't really write yet
-  def write_item(lemma,  # string: target lemma
-                 pos,    # string: target pos
-                 ids,    # array:string: unique IDs of this occurrence of the lemma
-                 sid,    # string: sentence ID
-                 senses,  # array:string: sense
-                 features) # features: hash feature type-> features (string-> array:string)
-
-
-    unless ["w", "a"].include? @mode
-      $stderr.puts "FredFeatures error: cannot write to feature file opened for reading"
-      exit 1
-    end
-
-    if lemma.nil? or lemma.empty? or ids.nil? or ids.empty?
-      # nothing to write
-      return
-    end
-    if pos.nil? or pos.empty?
-      # POS unknown
-      pos = ""
-    end
-
-    # falsch! noval nicht zulässig für fred! (nur für rosy!) - Warum steht das hier???
-    unless senses
-      senses = [ @exp.get("noval") ]
-    end
-
-    # modified by ines, 19.7.2010
-    # senses should be empty, but they are not - why?
-    if senses.length == 1 and senses[0].eql? "" 
-	senses = "NONE" 
-    end
-
-    writer = @w_tmp.get_writer_for(fred_lemmapos_combine(lemma, pos))
-    ids_s = ids.map { |i| i.gsub(/:/, "COLON") }.join("::")
-    
-    # AB: Ines modified <senses> and it can be a String.
-    # That's corrected, but I do not guarantee the correct results.
-    if senses.respond_to? :map
-      senses_s = senses.map { |s| s.gsub(/:/, "COLON") }.join("::")
-    end
-    writer.print "#{lemma} #{pos} #{ids_s} #{sid} #{senses_s} "
-
-    # write all features
-    @feature_extractors.each { |extractor|
-      extractor.each_feature(features) { |feature|
-        writer.print feature, " "
-      }
-    }
-    writer.puts
-    writer.flush()
-  end
-
-  ###
-  def flush()
-    unless ["w", "a"].include? @mode
-      $stderr.puts "FredFeatureAccess error: cannot write to feature file opened for reading"
-      exit 1
-    end
-
-    # elements in the feature vector: get fixed with the training data, 
-    # get read with the test data.
-    # get stored in feature_legend_dir
-    case @dataset
-    when "train"
-      feature_legend_dir = File.new_dir(fred_classifier_directory(@exp), 
-                                        "legend")
-    when "test"
-      feature_legend_dir= File.existing_dir(fred_classifier_directory(@exp), 
-                                        "legend")
-    end      
-
-    # now really write features
-    @w_tmp.flush()
-    @w_tmp.get_lemmas().sort().each { |lemmapos|
-   
-      # inform user
-      $stderr.puts "Writing #{lemmapos}..."
-
-      # prepare list of features to use in the feature vector:
-      legend_filename = feature_legend_dir + FredFeatureAccess.legend_filename(lemmapos)
-
-      case @dataset
-      when "train"
-        # training data: 
-        # determine feature list and sense list from the data,
-        # and store in the relevant file
-        feature_list, sense_list = collect_feature_list(lemmapos)
-        begin
-          f = File.new(legend_filename, "w")
-        rescue
-          $stderr.puts "Error: Could not write to feature legend file #{legend_filename}: " + $!
-          exit 1
-        end
-        f.puts feature_list.map { |x| x.gsub(/,/, "COMMA") }.join(",")
-        f.puts sense_list.map { |x| x.gsub(/,/, "COMMA") }.join(",")
-        f.close()
-
-      when "test"
-        # test data:
-        # read feature list and sense list from the relevant file
-      
-        begin
-          f = File.new(legend_filename)
-        rescue
-          $stderr.puts "Error: Could not read feature legend file #{legend_filename}: " + $!
-          $stderr.puts "Skipping this lemma."
-          next
-        end
-        feature_list = f.gets().chomp().split(",").map { |x| x.gsub(/COMMA/, ",") }
-        sense_list = f.gets().chomp().split(",").map { |x| x.gsub(/COMMA/, ",") }
-      end
-
-      # write
-      # - featurization file
-      # - answer key file
-
-      f = @w_tmp.get_for_reading(lemmapos)
-      answer_obj = AnswerKeyAccess.new(@exp, @dataset, lemmapos, "w")
-
-      obj_out = WriteFeaturesNaryOrBinary.new(lemmapos, @exp, @dataset)
-
-      f.each { |line| 
-
-        lemma, pos, ids, sid, senses, features = parse_temp_itemline(line)
-        unless lemma 
-          # something went wrong in parsing the line
-          next
-        end
-        each_sensegroup(senses, sense_list) { |senses_for_item, original_senses|
-          # write answer key
-          answer_obj.write_line(lemma, pos, 
-                                ids, sid, original_senses, senses_for_item)
-
-          # write item: features, senses
-	  obj_out.write_instance(to_feature_list(features, feature_list),
-				 senses_for_item)
-        } # each sensegroup
-      } # each input line
-      obj_out.close()
-      answer_obj.close()
-      @w_tmp.discard(lemmapos)
-    } # each lemma
-
-
-  end
-
-  ##################
-  protected
-
-  ###
-  # read temp feature file for the given lemma/pos
-  # and determine the list of all features and the list of all senses,
-  # each sorted alphabetically
-  def collect_feature_list(lemmapos)
-    # read entries for this lemma
-    f = @w_tmp.get_for_reading(lemmapos)
-
-    # keep a record of all senses and features
-    # senses: binary.
-    # features: keep the max. number of times a given feature occurred
-    #         in an instance
-    all_senses = Hash.new()
-    all_features = Hash.new(0)
-    features_this_instance = Hash.new(0)
-    # record how often each feature occurred all in all
-    num_occ = Hash.new(0)
-    num_lines = 0
-
-    f.each { |line|
-      lemma, pos, id_string, sid, senses, features = parse_temp_itemline(line)
-
-      unless lemma
-        # something went wrong in parsing the line
-        # print out the file contents for reference, then leave
-        $stderr.puts "Could not read temporary feature file #{f.path()} for #{lemmapos}."
-        exit 1
-      end
-      num_lines += 1
-      senses.each { |s| all_senses[s] = true }
-      features_this_instance.clear()
-      features.each { |fea| 
-        features_this_instance[fea] += 1 
-        num_occ[fea] += 1
-      }
-      
-      features_this_instance.each_pair { |feature, value|
-        all_features[feature] = [ all_features[feature], features_this_instance[feature] ].max()
-      }
-    }
-
-    # HIER 
-    # if num_lines > 2
-    #  num_occ.each_pair { |feature, num_occ|
-    #    if num_occ < 2
-    #      all_features.delete(feature)
-    #    end
-    #  }
-    # end
-    
-
-
-    case @exp.get("numerical_features")
-    when "keep"
-      # leave numerical features as they are, or 
-      # don't do numerical features
-      return [ all_features.keys().sort(),
-               all_senses.keys().sort()
-             ]
-
-    when "repeat"
-      # repeat: turn numerical feature with max. value N
-      # into N binary features
-      feature_list = Array.new()
-      all_features.keys().sort().each { |feature|
-        all_features[feature].times() { |index| 
-          feature_list << feature + " #{index}/#{all_features[feature]}" 
-        }
-      }
-      return [ feature_list, 
-               all_senses.keys().sort()
-             ]
-
-    when "bin"
-      # make bins:
-      # number of bins = (max. number of occurrences of a feature per item) / 10
-      feature_list = Array.new()
-      all_features.keys().sort().each { |feature|
-        num_bins_this_feature = (all_features[feature].to_f() / 10.0).ceil().to_i()
-
-        num_bins_this_feature.times { |index| 
-          feature_list << feature  + " #{index}/#{num_bins_this_feature}"
-        }
-      }
-      return [ feature_list,
-               all_senses.keys().sort()
-             ]
-    else
-      raise "Shouldn't be here"
-    end
-  end
-
-
-  ###
-  # given a full sorted list of items and a partial list of items,
-  # match the partial list to the full list,
-  # that is, produce as many items as the full list has
-  # yielding 0 where the partial entry is not in the full list, 
-  # and > 0 otherwise
-  #
-  # Note that if partial contains items not in full,
-  # they will not occur on the feature list returned!
-  def to_feature_list(partial, full,
-                      handle_numerical_features = nil)
-
-    #print "FULL: ", full, "\n"
-    #print "PART: ", partial, "\n"
-    # count occurrences of each feature in the partial list
-    occ_hash = Hash.new(0)
-    partial.each { |p|
-      occ_hash[p] += 1
-    }
-
-    # what to do with our counts?
-    unless handle_numerical_features
-      # no pre-set value given when this function was called
-      handle_numerical_features = @exp.get("numerical_features")
-    end
-
-    case handle_numerical_features
-    when "keep"
-      # leave numerical features as numerical features
-      return full.map { |x|
-        occ_hash[x].to_s()
-      }
-
-    when "repeat"
-      # repeat each numerical feature up to a max. number of occurrences
-      return full.map { |feature_plus_count|
-        unless feature_plus_count =~ /^(.*) (\d+)\/(\d+)$/
-          $stderr.puts "Error: could not parse feature: #{feature_plus_count}, bailing out."
-          raise "Shouldn't be here."
-        end
-
-        feature = $1
-        current_count = $2.to_i()
-        max_num = $3.to_i()
-
-        if occ_hash[feature] > current_count
-          1
-        else
-          0
-        end
-      }    
-
-    when "bin"
-      # group numerical feature values into N bins.
-      # number of bins varies from feature to feature
-      # each bin contains 10 different counts
-      return full.map { |feature_plus_count|
-        unless feature_plus_count =~ /^(.*) (\d+)\/(\d+)$/
-          $stderr.puts "Error: could not parse feature: #{feature_plus_count}, bailing out."
-          raise "Shouldn't be here."
-        end
-
-        feature = $1
-        current_count = $2.to_i()
-        max_num = $3.to_i()
-
-        if occ_hash[feature] % 10 > (10 * current_count)
-          1
-        else
-          0
-        end
-      }
-    else
-      raise "Shouldn't be here"
-    end
-  end
-
-
-  ###
-  # how to treat instances with multiple senses?
-  # - either write one item per sense
-  # - or combine all senses into one string
-  # - or keep as separate senses
-  #
-  # according to 'handle_multilabel' in the experiment file
-  #
-  # yields pairs of [senses, original_senses]
-  # both are arrays of strings
-  def each_sensegroup(senses, full_sense_list)
-    case @exp.get("handle_multilabel")
-    when "keep"
-      yield [senses, senses]
-    when "join"
-      yield [ [fred_join_senses(senses)], senses]
-    when "repeat"
-      senses.each { |s|
-        yield [ [s], senses]
-      }
-    when "binarize"
-      yield [ senses, senses ]
-    else
-      $stderr.puts "Error: unknown setting #{exp.get("handle_multilabel")}"
-      $stderr.puts "for 'handle_multilabel' in the experiment file."
-      $stderr.puts "Please choose one of 'binary', 'keep', 'join', 'repeat'"
-      $stderr.puts "or leave unset -- default is 'binary'."
-      exit 1
-    end
-  end
-
-  ###
-  def parse_temp_itemline(line)
-    lemma, pos, ids_s, sid, senses_s, *features = line.split()
-    # fix me! senses is empty, takes context features instead
-    unless senses_s
-      # features may be empty, but we need senses
-      $stderr.puts "FredFeatures Error in word sense item line: too short."
-      $stderr.puts ">>#{line}<<"
-      return nil
-    end
-    
-    ids = ids_s.split("::").map { |i| i.gsub(/COLON/, ":") }
-    senses = senses_s.split("::").map { |s| s.gsub(/COLON/, ":") }
-
-    return [lemma, pos, ids, sid, senses, features]
-  end
-
-end
-
-########################################
-# read and write access to answer key files
-# manages a single answer key file for a given lemma/POS pair
-class AnswerKeyAccess
-  ###
-  def initialize(exp,      # experiment file object
-                 dataset,  # "train", "test"
-                 lemmapos, # lemma + POS (one string)
-                 mode,     # "r", "w", "a"
-                 split_id = nil,
-                 split_dataset = nil)
-    unless ["r", "w", "a"].include? mode
-      $stderr.puts "FredFeatures error: AnswerKeyAccess initialized with mode #{mode}."
-      exit 1
-    end
-
-    @mode = mode
-    
-    answer_filename = fred_dirname(exp, dataset, "keys", "new") +
-      fred_answerkey_filename(lemmapos)
-
-    # are we reading the whole answer key file, or only the test part
-    # of a split of it?
-    if split_id
-      # we are accessing part of a split
-      # we can only do that when reading!
-      unless @mode == "r"
-        $stderr.puts "AnswerKeyAccess error: cannot access split answer file in write mode."
-        exit 1
-      end
-
-      # apply_split returns a closed temporary file
-      split_obj = FredSplitPkg.new(exp)
-      @f = split_obj.apply_split(answer_filename, lemmapos, split_dataset, split_id)
-      if @f.nil?
-        # the split_dataset part of the split doesn't contain any data
-        $stderr.puts "Warning: no #{split_dataset} data for lemma #{lemmapos}"
-      else
-        @f.open()
-      end
-
-    else
-      # we are reading the whole thing
-      begin
-        @f = File.new(answer_filename, @mode)
-      rescue
-        @f = nil
-      end
-    end
-  end
-
-  ###
-  def write_line(lemma,     # string: lemma
-                 pos,       # string: POS
-                 ids,       # array:string: target IDs
-                 sid,       # string: sentence ID
-                 senses,    # array:string: senses
-                 senses_this_item) # array:string: senses for this item
-    unless ["w", "a"].include? @mode
-      $stderr.puts "FredFeatures error: AnswerKeyAccess: cannot write in read mode."
-      exit 1
-    end
-    unless @f
-      raise "Shouldn't be here"
-    end
-    
-    # write answer key:
-    # lemma POS ID senses
-    if senses.include? nil or senses.include? ""
-      raise "empty sense"
-    end
-    if senses_this_item.include? nil or senses_this_item.include? ""
-      raise "empty sense for this item"
-    end
-
-    senses_s = senses.map { |s| s.gsub(/,/, "COMMA")}.join(",")
-    senses_ti_s = senses_this_item.map { |s| 
-      s.gsub(/,/, "COMMA")}.join(",")
-    id_s = ids.map { |i| i.gsub(/:/, "COLON") }.join("::")
-
-    @f.puts "#{lemma} #{pos} #{id_s} #{sid} #{senses_s} #{senses_ti_s}"
-  end
-
-  ###
-  # yield one line at a time:
-  # tuple (lemma, POS, ids, sentence_ID, all_assigned_senses, transformed_senses_for_this_item)
-  def each()
-    unless @mode == "r"
-      $stderr.puts "FredFeatures error: AnsewrKeyAccess: cannot read in write mode"
-    end
-    unless @f
-      # something went wrong during initialization:
-      # split didn't contain data
-      return
-    end
-
-    @f.each { |line|
-
-      lemma, pos, id_s, sid, senses_s, senses_this_item_s = line.split()
-      ids = id_s.split("::").map { |i| i.gsub(/COLON/, ":") }
-      senses = senses_s.split(",").map { |s| s.gsub(/COMMA/, ",") }
-
-      senses_this_item = senses_this_item_s.split(",").map { |s|
-        s.gsub(/COMMA/, ",") }
-
-      yield [lemma, pos, ids, sid, senses, senses_this_item]
-    }
-  end
-
-  ###
-  def close()
-    @f.close()
-  end
-
-  ###
-  def AnswerKeyAccess.remove_files(exp, dataset)
-    Dir[fred_dirname(exp, dataset, "keys", "new") + fred_answerkey_filename("*")].each { |filename|
-      if File.exists?(filename)
-        File.delete(filename)
-      end
-    }
-  end
-end
-
-
-####################3
-# keep writers: auxiliary class for FredFeatureAccess:
-# write to several files at a time
-# in tempfiles
-class AuxKeepWriters
-  def initialize()
-    @lemma2temp = Hash.new()
-    @size = 50
-    @writers = Array.new()
-  end
-
-
-  ##
-  def flush()
-    @writers.each { |lemmapos, writer|
-      writer.close()
-    }
-  end
-
-  ##
-  def get_lemmas()
-    return @lemma2temp.keys()
-  end
-
-  ##
-  def get_for_reading(lemmapos)
-    if @lemma2temp[lemmapos]
-      # we have a writer for this
-
-      @lemma2temp[lemmapos].close()
-      @lemma2temp[lemmapos].open()
-      return @lemma2temp[lemmapos]
-
-    else
-      # no writer for this
-      return nil
-    end
-  end
-  
-  ##
-  # finally close temp file, remove information for lemma/pos
-  def discard(lemmapos)
-    if @lemma2temp[lemmapos]
-      @lemma2temp[lemmapos].close(true)
-      @lemma2temp.delete(lemmapos)
-    end
-  end
-
-  ##
-  def get_writer_for(lemmapos)
-
-    # is there a temp file for this lemma/pos combination?
-    unless @lemma2temp[lemmapos]
-      @lemma2temp[lemmapos] = Tempfile.new("fred_features")
-      @lemma2temp[lemmapos].close()
-    end
-
-    # is there an open temp file for this lemma/pos combination?
-    pair = @writers.assoc(lemmapos)
-    if pair
-      return pair.last()
-    end
-
-    # no: open the temp file, kick some other temp file out of the
-    # @writers list
-    writer = @lemma2temp[lemmapos]
-    writer.open()
-    
-
-    # writer: open for appending
-    writer.seek(0, IO::SEEK_END)
-   
-
-    @writers << [lemmapos, writer]
-    if @writers.length() > @size
-      # close file associated with first writer
-      @writers.first.last.close()
-      @writers.shift()
-    end
-    return writer
-  end
-
-  ###
-  def remove_files()
-    @lemma2temp.each_value { |x|
-      x.close(true)
-    }
-  end
-end
-
-##############
-# write features,
-# either lemma-wise
-# or lemma+sense-wise
-# if lemma+sense-wise, write as binary classifier,
-# i.e. map the target senses 
-#
-# Use Delegator.
-
-###
-# Features for N-ary classifiers
-class WriteFeaturesNary
-  def initialize(lemma,
-		 exp,
-		 dataset,
-		 feature_dir)
-
-    @filename = feature_dir + fred_feature_filename(lemma)
-    @f = File.new(@filename, "w")
-    @handle_multilabel = exp.get("handle_multilabel")
-  end
-
-  def write_instance(features, senses)
-
-    @f.print features.map { |x|
-      x.to_s().gsub(/,/, "COMMA").gsub(/;/, "SEMICOLON")
-    }.join(",")
-
-    # possibly more than one sense? then use semicolon to separate
-    if @handle_multilabel == "keep"
-      # possibly more than one sense: 
-      # separate by semicolon,
-      # and hope that the classifier knows this
-      @f.print ";"
-      @f.puts senses.map {|x|
-        x.to_s().gsub(/,/, "COMMA").gsub(/;/, "SEMICOLON")
-      }.join(",")
-    else
-      # one sense: just separate by comma
-      @f.print ","
-      @f.puts senses.first().to_s().gsub(/,/, "COMMA").gsub(/;/, "SEMICOLON")
-    end
-  end
-
-  def close()
-    @f.close()
-  end
-end
-
-###
-# Features for binary classifiers
-class WriteFeaturesBinary
-  def initialize(lemma,
-		 exp,
-		 dataset,
-		 feature_dir)
-    @dir = feature_dir
-    @lemma = lemma
-    @feature_dir = feature_dir
-
-    @negsense = exp.get("negsense")
-    unless @negsense
-      @negsense = "NONE"
-    end
-
-    # files: sense-> filename
-    @files = Hash.new()
-
-    # keep all instances such that, when a new sense comes around,
-    # we can write them for that sense
-    @instances = Array.new()
-  end
-
-
-  def write_instance(features, senses)
-    # sense we haven't seen before? Then we need to
-    # write the whole featurization file for that new sense
-    check_for_presence_of_senses(senses)
-
-    # write this new instance for all senses
-    @files.each_key { |sense_of_file|
-      write_to_sensefile(features, senses, sense_of_file)
-    }
-
-    # store instance in case another sense crops up later
-    @instances << [features, senses]
-  end
-
-
-  ###
-  def close()
-    @files.each_value { |f| f.close() }
-  end
-
-  ######
-  private
-
-  def check_for_presence_of_senses(senses)
-    senses.each { |sense|
-      # do we have a sense file for this sense?
-      unless @files[sense]
-        # open new file for this sense
-        @files[sense] = File.new(@feature_dir + fred_feature_filename(@lemma, sense, true), "w")
-        # filename = @feature_dir + fred_feature_filename(@lemma, sense, true)
-        # $stderr.puts "Starting new feature file #{filename}"
-
-        # and re-write all previous instances for it
-        @instances.each { |prev_features, prev_senses|
-          write_to_sensefile(prev_features, prev_senses, 
-                             sense)
-        }
-      end
-    }
-  end
-
-  ###
-  def write_to_sensefile(features, senses,
-			 sense_of_file)
-    # file to write to
-    f = @files[sense_of_file]
-
-    # print features
-    f.print features.map { |x|
-      x.to_s().gsub(/,/, "COMMA")
-    }.join(",")
-
-    f.print ","
-
-    # binarize target class
-    if senses.include? sense_of_file
-      # $stderr.puts "writing POS #{sense_of_file}"
-      f.puts sense_of_file.to_s()
-    else
-      # $stderr.puts "writing NEG #{negsense}"
-      f.puts @negsense
-    end
-
-  end
-end
-
-########
-# class writing features:
-# delegating to either a binary or an n-ary writer
-class WriteFeaturesNaryOrBinary < SimpleDelegator
-  ###
-  def initialize(lemma, 
-		 exp,
-		 dataset)
-    feature_dir = WriteFeaturesNaryOrBinary.feature_dir(exp, dataset, "new")
-    if exp.get("binary_classifiers")
-      # binary classifiers
-      # $stderr.puts "Writing binary feature data."
-
-      # delegate writing to the binary feature writer
-      @writer = WriteFeaturesBinary.new(lemma, exp, dataset, feature_dir)
-      super(@writer)
-
-    else
-      # n-ary classifiers
-      # $stderr.puts "Writing n-ary feature data."
-
-      # delegate writing to the n-ary feature writer
-      @writer = WriteFeaturesNary.new(lemma, exp, dataset, feature_dir)
-      super(@writer)
-    end
-  end
-
-  def WriteFeaturesNaryOrBinary.feature_dir(exp, dataset,
-                                            mode = "existing")
-    return fred_dirname(exp, dataset, "features", mode)
-  end
-
-  ###
-  def WriteFeaturesNaryOrBinary.remove_files(exp, dataset)
-    feature_dir = WriteFeaturesNaryOrBinary.feature_dir(exp, dataset, "new")
-
-    Dir[feature_dir + fred_feature_filename("*")].each { |filename|
-      if File.exists? filename
-	File.delete(filename)
-      end
-    }
-  end
-end