shalmaneser 1.2.0.rc4 → 1.2.rc5

data/lib/common/FixSynSemMapping.rb

@@ -1,196 +0,0 @@
-###
-# FixSynSemMapping:
-# Given a SalsaTigerRegXML sentence with semantic role annotation,
-# simplify the mapping of semantic roles to syntactic constituents
-# 
-# The following is lifted from the LREC06 paper on Shalmaneser:
-# During preprocessing, the span of semantic roles in the training corpora is 
-# projected onto the output of the syntactic parser by assigning each
-# role to the set of maximal constituents covering its word span.
-# f the word span of a role does not coincide
-# with parse tree constituents, e.g. due to misparses,
-# the role is ``spread out'' across several constituents. This leads to
-# idiosyncratic paths between predicate and semantic role in the parse
-# tree. 
-#
-# [The following span standardization algorithm is used to make the
-# syntax-semantics mapping more uniform:]
-# Given a role r that has been assigned, let N be the set of
-# terminal nodes of the syntactic structure that are covered by r. 
-#
-#   Iteratively compute the maximal projection of N in the syntactic
-#   structure: 
-#   1) If n is a node such that all of n's children are in N,
-#     then remove n's children from N and add n instead.
-#   2) If n is a node with 3 or more children, and all of n's
-#     children except one are in N, then remove n's children from N
-#     and add n instead. 
-#   3) If n is an NP with 2 children, and one of them, another NP,
-#     is in N, and the other, a relative clause, is not, then remove
-#     n's children from N and add n instead.
-#
-#   If none of the rules is applicable to N anymore, assign r to the
-#   nodes in N.
-#
-# Rule 1 implements normal maximal projection. Rule 2 ``repairs'' parser
-# errors where all children of a node but one have been assigned the
-# same role. Rule 3 addresses a problem of the FrameNet data, where
-# relative clauses have been omitted from roles assigned to NPs. 
-
-# KE Feb 08: rule 3 currently out of commission!
-
-require "common/SalsaTigerRegXML"
-
-module FixSynSemMapping
-  ##
-  # fix it
-  #
-  # relevant settings in the experiment file:
-  #
-  # fe_syn_repair:
-  # If there is a node that would be a max. constituent for the
-  # words covered by the given FE, except that it has one child
-  # whose words are not in the FE, use the node as max constituent anyway.
-  # This is to repair cases where the parser has made an attachment choice
-  # that differs from the one in the gold annotation
-  #
-  # fe_rel_repair:
-  # If there is an NP such that all of its children except one have been
-  # assigned the same FE, and that missing child is a relative clause
-  # depending on one of the other children, then take the complete NP as
-  # that FE
-  def FixSynSemMapping.fixit(sent, # SalsaTigerSentence object
-                             exp,  # experiment file object
-                             interpreter_class) # SynInterpreter class
-
-    
-    unless exp.get("fe_syn_repair") or exp.get("fe_rel_repair")
-      return 
-    end
-
-    if sent.nil?
-	return
-    end
-
-    # "repair" FEs: 
-    sent.each_frame { |frame|
-
-      frame.each_child { |fe_or_target|
-
-        # repair only if the FE currently
-        # points to more than one syn node
-        if fe_or_target.children.length() < 2
-          next
-        end
-
-        if exp.get("fe_rel_repair")
-          lastfe = fe_or_target.children.last()
-          if lastfe and interpreter_class.simplified_pt(lastfe) =~ /^(WDT)|(WP\$?)|(WRB)/
-
-            # remove syn nodes that the FE points to
-            old_fe_syn = fe_or_target.children()
-            old_fe_syn.each { |child|
-              fe_or_target.remove_child(child)
-            }
-
-            # set it to point only to the last previous node, the relative pronoun
-            fe_or_target.add_child(lastfe)
-          end
-        end
-
-        if exp.get("fe_syn_repair")
-          # remove syn nodes that the FE points to
-          old_fe_syn = fe_or_target.children()
-          old_fe_syn.each { |child|
-            fe_or_target.remove_child(child)
-          }
-
-          # and recompute
-          new_fe_syn = interpreter_class.max_constituents(old_fe_syn.map { |t| 
-                                                            t.yield_nodes
-                                                          }.flatten.uniq, 
-                                                          sent, 
-                                                          exp.get("fe_syn_repair"))
-            
-          # make the FE point to the new nodes
-          new_fe_syn.each { |syn_node|
-            fe_or_target.add_child(syn_node)
-          }
-        end
-      } # each FE
-    } # each frame
-  end # def fixit
-end # module
-
-
-#########3
-# old code
-
-#     if exp.get("fe_rel_repair")
-#       # repair relative clauses:
-#       # then make a procedure to pass on to max constituents
-#       # that will recognize the relevant cases
-
-#       accept_anyway_proc = Proc.new { |node, children_in, children_out|
-
-#         # node: SynNode
-#         # children_in, children_out: array:SynNode. children_in are the children
-#         #    that are already covered by the FE, children_out the ones that aren't
-          
-#         # if node is an NP,
-#         # and only one of its children is out, 
-#         # and one node in children_in is an NP, and the missing child is an SBAR
-#         # with a child that is a relative pronoun, then consider the child in children_out as covered
-#         if interpreter_class.category(node) == "noun" and 
-#             children_out.length() == 1 and
-#             children_in.select { |n| interpreter_class.category(n) == "noun" } and
-#             interpreter_class.category(children_out.first) == "sent" and 
-#             (ch = children_out.first.children) and  
-#             ch.select { |n| interpreter_class.relative_pronoun?(n) }
-#           true
-#         else
-#           false
-#         end
-#       }
-
-#     else
-#       accept_anyway_proc = nil
-#     end
-
-
-#     # "repair" FEs: 
-#     sent.each_frame { |frame|
-
-#       frame.each_child { |fe_or_target|
-
-#         # repair only if the FE currently
-#         # points to more than one syn node, or
-#         # if it is a noun with a non-covered sentence sister
-#         if fe_or_target.children.length() > 1 or
-#             (exp.get("fe_rel_repair") and (curr_marked = fe_or_target.children.first())  and
-#              interpreter_class.category(curr_marked) == "noun" and
-#              (p = curr_marked.parent) and 
-#              p.children.select { |n| n != curr_marked and interpreter_class.category(n) == "sent" } )
-
-#           # remember nodes covered by the FE
-#           old_fe_syn = fe_or_target.children()
-
-#           # remove syn nodes that the FE points to
-#           old_fe_syn.each { |child|
-#             fe_or_target.remove_child(child)
-#           }
-
-#           # and recompute
-#           new_fe_syn = interpreter_class.max_constituents(old_fe_syn.map { |t| t.yield_nodes}.flatten.uniq, 
-#                                                           sent, 
-#                                                           exp.get("fe_syn_repair"),
-#                                                           accept_anyway_proc)
-            
-#           # make the FE point to the new nodes
-#           new_fe_syn.each { |syn_node|
-#             fe_or_target.add_child(syn_node)
-#           }
-
-#         end # if FE points to more than one syn node
-#       } # each FE
-#     } # each frame

data/lib/common/Graph.rb

@@ -1,345 +0,0 @@
-# GraphNode: describes one node in a graph.
-#
-# A node may have an arbitrary number of parents (sources of incoming edges)
-# and an arbitrary number of children (targets of outgoing edges)
-#
-# All edges are labeled and directed
-#
-# The add_parent, add_child, remove_parent, remove_child methods
-# take care of both ends of an edge 
-# (i.e. n1.add_child(n2, label) also adds n1 as parent of n2 with edge label 'label'
-#
-# It is possible to create a 'pointer' rather than an edge:
-#     n1.add_child(n2, label, pointer_insteadof_edge => true) 
-# will create an edge from n1 to n2 labeled 'label' that is
-# listed under the outgoing edges of n1, but not among
-# the incoming edges of n2
-# The same option is available for add_parent, remove_parent, remove_child.
-
-class GraphNode
-
-  def initialize(id)
-    @id = id
-    @children = Array.new
-    @parents = Array.new
-    @features = Hash.new
-  end
-
-  # for Marshalling: 
-  # Dump just IDs instead of actual nodes from Parents and Children lists.
-  # Otherwise the Marshaller will go crazy following
-  # all the links to objects mentioned.
-  # After loading: replace IDs by actual objects with a little help
-  # from the caller.
-
-  def _dump(depth)
-    @id.to_s +
-      "QQSEPVALUESQQ" +
-      Marshal.dump(@features) +
-      "QQSEPVALUESQQ" +
-      @children.map { |label_child| 
-        label_child[0] + "QQSEPQQ" + label_child[1].id()
-      }.join("QQPAIRQQ") +
-      "QQSEPVALUESQQ" +
-      @parents.map { |label_parent|
-        label_parent[0] + "QQSEPQQ" + label_parent[1].id()
-    }.join("QQPAIRQQ")      
-  end
-
-  def GraphNode._load(string)
-    id, features_s, children_s, parents_s =
-      string.split("QQSEPVALUESQQ")
-
-    result = GraphNode.new(id)
-    result.fill_from_pickle(string)
-    return result
-  end
-
-  def fill_from_pickle(string)
-    id, features_s, children_s, parents_s =
-      string.split("QQSEPVALUESQQ")
-
-    @features = Marshal.load(features_s)
-
-    if children_s.nil? or children_s.empty?
-      @children = []
-    else
-      @children = children_s.split("QQPAIRQQ").map { |pair|
-	pair.split("QQSEPQQ")
-      }
-    end
-
-    if parents_s.nil? or parents_s.empty?
-      @parents = []
-    else
-      @parents = parents_s.split("QQPAIRQQ").map { |pair|
-	pair.split("QQSEPQQ")
-      }
-    end
-  end
-
-  def recover_from_dump(node_by_id)
-    @children = @children.map { |label_id| [label_id[0], node_by_id.call(label_id[1])] }
-    @parents = @parents.map { |label_id| [label_id[0], node_by_id.call(label_id[1])] }
-  end
-
-  # ID-related things
-
-  def ==(other_node)
-    unless other_node.kind_of? GraphNode
-      return false
-    end
-    @id == other_node.id()
-  end
-
-  def id()
-    return @id
-  end
-
-  def chid(newid)
-    @id = newid
-  end
-
-  # setting and retrieving features
-
-  def get_f(feature)
-    return @features[feature]
-  end
-
-  def set_f(feature, value)
-    @features[feature] = value
-  end
-
-  def add_f(feature, value)
-    unless @features[feature].nil?
-      raise "Feature " + feature + "already set."
-    end
-    set_f(feature, value)
-  end
-  
-  # ancestors 
-
-  def parents()
-    return @parents.map { |label_parent| 
-      label_parent[1] }
-  end
-  
-  def parent_labels()
-    return @parents.map { |label_parent| label_parent[0] }
-  end
-
-  def parent_label(parent)
-    @parents.each { |label_parent|
-      if label_parent[1] == parent 
-	return label_parent[0]
-      end
-    }
-    return nil
-  end
-
-  def parents_with_edgelabel()
-    return @parents
-  end
-
-  def each_parent()
-    @parents.each { |label_parent| yield label_parent[1] }
-  end
-
-  def each_parent_with_edgelabel()
-    @parents.each { |label_parent| yield label_parent}
-  end
-
-  def parents_by_edgelabels(labels)
-    return @parents.select { |label_parent|
-      labels.include? label_parent[0]
-    }.map { |label_parent|
-      label_parent[1]
-    }
-  end
-
-  def add_parent(parent, edgelabel, varhash={})
-    @parents << [edgelabel, parent]
-
-    # and vice versa: add self as child to parent
-    unless varhash["pointer_insteadof_edge"]
-      unless parent.children_with_edgelabel().include? [edgelabel, self]
-        parent.add_child(self, edgelabel)
-      end
-    end
-  end
-
-  def remove_parent(parent, edgelabel, varhash={})
-    @parents = @parents.reject { |label_child| 
-      label_child.first == edgelabel and
-	label_child.last == parent
-    }
-
-    # and vice versa: remove self as child from parent
-    unless varhash["pointer_insteadof_edge"]
-      if parent.children_with_edgelabel().include? [edgelabel, self]
-        parent.remove_child(self, edgelabel)
-      end
-    end
-  end
-
-  def indeg()
-    return @parents.length()
-  end
-
-  def ancestors
-    return ancestors_noduplicates([], [])
-  end
-
-  def ancestors_by_edgelabels(labels)
-    return ancestors_noduplicates([], labels)
-  end
-
-  # descendants
-
-  def children()
-    return @children.map { |label_child| label_child[1] }
-  end
-
-  def child_labels()
-    return @children.map { |label_child| label_child[0] }
-  end
-
-  def child_label(child)
-    @children.each { |label_child|
-      if label_child[1] == child
-	return label_child[0]
-      end
-    }
-    return nil
-  end
-
-  def children_with_edgelabel()
-    return @children
-  end
-
-  def each_child()
-    @children.each { |label_child| yield label_child[1]}
-  end
-
-  def each_child_with_edgelabel()
-    @children.each { |label_child| yield label_child } 
-  end
-
-  def children_by_edgelabels(labels)
-    return @children.select { |label_child|
-      labels.include? label_child[0] 
-    }.map { |label_child|
-      label_child[1]
-    }
-  end
-
-  def add_child(child, edgelabel, varhash={})
-    @children << [edgelabel, child]
-
-    # and vice versa: add self as parent to child
-    unless varhash["pointer_insteadof_edge"]
-      unless child.parents_with_edgelabel().include? [edgelabel, self]
-        child.add_parent(self, edgelabel)
-      end
-    end
-  end
-
-  def remove_child(child, edgelabel, varhash={})
-    @children = @children.reject { |label_child| 
-      label_child.first == edgelabel and
-	label_child.last == child
-    }
-
-    # and vice versa: remove self as parent from child
-    unless varhash["pointer_insteadof_edge"]
-      if child.parents_with_edgelabel().include? [edgelabel, self]
-        child.remove_parent(self, edgelabel)
-      end
-    end
-  end
-
-  def change_child_label(child, oldlabel, newlabel, varhash={})
-    if @children.include? [oldlabel, child]
-      remove_child(child,oldlabel, varhash)
-      add_child(child, newlabel, varhash)
-    end
-  end
-
-  def remove_all_children(varhash={})
-    each_child_with_edgelabel { |label, child|
-      remove_child(child, label, varhash)
-    }
-  end
-
-  def set_children(list, varhash={})
-    #### CAUTION: set_children must be called with an "internal format" list of parents:
-    ####          instead of using [node, edgelabel], use [edgelabel, node]
-    remove_all_children(varhash)
-
-    @children = list
-  end
-
-  def outdeg()
-    return @children.length()
-  end
-
-  def yield_nodes()
-    arr = Array.new
-    if outdeg() == 0
-      arr << self
-    end
-    each_child { |c| 
-      if c.outdeg() == 0
-	arr << c
-      else
-	arr.concat c.yield_nodes
-      end
-    }
-    return arr
-  end
-
-  def descendants
-    return descendants_noduplicates([], [])
-  end
-
-  def descendants_by_edgelabels(labels)
-    return descendants_noduplicates([], labels)
-  end
-
-  protected
-
-  def descendants_noduplicates(nodes, labels)
-    each_child_with_edgelabel() { |l_c|
-      if labels.empty? or labels.include? l_c[0]
-	unless nodes.include? l_c[1]
-	  nodes = l_c[1].descendants_noduplicates(nodes << l_c[1], labels)
-	end
-      end
-    }
-    return nodes
-  end
-  
-  def ancestors_noduplicates(nodes, labels)
-    each_parent_with_edgelabel() { |l_p|
-      if labels.empty? or labels.include? l_p[0]
-	unless nodes.include? l_p[1]
-	  nodes = l_p[1].ancestors_noduplicates(nodes << l_p[1], labels)
-	end
-      end
-    }
-    return nodes
-  end
-
-  #### CAUTION: set_parents must be called with an "internal format" list of parents:
-  ####          instead of using [node, edgelabel], use [edgelabel, node]
-
-  def set_parents(list, varhash={})
-    each_parent_with_edgelabel { |label, parent|
-      remove_parent(parent, label, varhash)
-    }
-
-    list.each { |label, parent|
-      add_parent(label, parent)
-    }
-  end
-end