semantic_framer.py

Go to the documentation of this file.

#!/usr/bin/env python
# semantic_framer.py

import roslib; roslib.load_manifest('semantic_framer')
import rospy
import os
import sys
import yaml
from roboframenet_msgs.msg import *
from roboframenet_msgs.srv import *
from stanford_parser_msgs.msg import Parse
from stanford_parser_msgs import unsquash_tree




###############################################################################
### Internal Classes

class _Verb():
    def __init__(self, name, index):
        self.name = name
        self.index = index
        self.is_negated = False

    def negate(self):
        self.is_negated = not self.is_negated

    def __repr__(self):
        return ("<_Verb '" + self.name + "' (index " + str(self.index) + "): " +
                ("not " if (not self.is_negated) else "") + "negated>")



class _LexicalUnit(object):
    def __init__(self, name, verb):
        self.frame_name = name # string
        self.verb = verb # string
        self.frame_element_grammatical_relations = [] #listof(_FrameElementGrammaticalRelation)

    # Returns listof(_LexicalUnit).
    @staticmethod
    def import_yaml(yaml):
        lus = []
        try:
            # yaml is either a single lu entry or a listof(lu entry)
            for yaml in listify(yaml):
                # verb is either a single verb or a listof(verb)
                for verb in listify(yaml['verb']):
                    lu = _LexicalUnit(yaml['frame_name'], verb)
                    frame = get_EmptySemanticFrame(lu.frame_name)
                    if 'frame_element_grammatical_relations' in yaml:
                        for gr in yaml['frame_element_grammatical_relations']:
                            # Check coreness with frame (assume False if not found,
                            #   since we won't be mapping it.)
                            is_core = False
                            for fe in frame.frame_elements:
                                if fe.name == gr['name']:
                                    is_core = fe.is_core
                                    break
                            lu.frame_element_grammatical_relations.append(
                                _FrameElementGrammaticalRelation(gr['name'],
                                                                 gr['relation'],
                                                                 is_core))
                    lus.append(lu)
        except:
            rospy.logerr("Error converting yaml to _LexicalUnit: " +
                         str(sys.exc_info()))
        else:
            return lus

    def __str__(self):
        return "<_LexicalUnit '" + self.verb + "' -> '" + self.frame_name + "'>"



class _FrameElementGrammaticalRelation:
    def __init__(self, name, relation, is_core):
        self.name = name # string
        self.relation = relation # string
        self.is_core = is_core





###############################################################################
### Helpers (External)

def get_EmptySemanticFrame(frame_name):
    rospy.wait_for_service('get_empty_frame')
    try:
        srv = rospy.ServiceProxy('get_empty_frame', GetEmptyFrame)
        frame = srv(frame_name).frame
    except rospy.ServiceException, e:
        print "Service call failed: %s"%e
        return False
    return frame




###############################################################################
### Helpers (Internal)

def listify(x):
    return x if isinstance(x, list) else [x]

# Returns dict(listof(_LexicalUnit)); Dictionary keyed by index of verb.
def get_empty_lexical_units(msg):
    # Force all words in the sentence to be lower case.  This makes
    #   capitalization a non-issue for, eg, verbs at the start of a
    #   sentence, or for any other sort of comparison in general.
    for i in range(len(msg.words)):
        msg.words[i] = msg.words[i].lower()
    # Unsquash the parse tree and find the verb
    parse_tree = unsquash_tree(msg)
    # Ignore negated verbs.  (We don't want the robot to start doing something
    #   you said not to do.  eg, "Don't break my dishes!")
    verbs = filter(lambda verb: not verb.is_negated,
                   find_verbs_in_parse(parse_tree,
                                       msg.dependencies,
                                       msg.words))
    # Get verb-relevant lexical units
    rospy.loginfo("semantic_framer: Retrieving empty lexical units for " +
                  str(len(verbs)) + " verb(s): '" +
                  "', '".join(map(lambda v: v.name, verbs)) + "'.")
    all_empty_lexical_units = dict()
    for verb in verbs:
        all_empty_lexical_units[verb.index] = get_lexical_units(verb.name)
    num_elus = sum([len(elus)
                    for verb_index, elus
                    in all_empty_lexical_units.items()])
    rospy.loginfo("semantic_framer: Retrieved " + str(num_elus) +
                  " empty lexical unit(s):\n" +
                  "verb\t->\tsemantic frame\n" +
                  "---------------------------------\n" +
                  '\n'.join(map(lambda elu: (elu.verb +
                                             '\t->\t' +
                                             elu.frame_name),
                                sum([elus
                                     for verb_index, elus
                                     in all_empty_lexical_units.items()],
                                    []))) +
                  '\n')
    return all_empty_lexical_units, num_elus



def find_verbs_in_parse(tree, dependencies, words):
    def find_all_verbs(tree):
        # Pull out all verbs:
        # VB - Verb, base form
        # VBD - Verb, past tense
        # VBG - Verb, gerund or present participle
        # VBN - Verb, past participle
        # VBP - Verb, non-3rd person singular present
        # VBZ - Verb, 3rd person singular present
        verbs = []
        if (tree.word and
            tree.tag in ["VB", "VBD", "VBG", "VBN", "VBP", "VBZ"]):
            verbs.append(_Verb(tree.word, tree.word_index))
        # Get verbs from children
        for child in tree.children:
            verbs.extend(find_all_verbs(child))
        return verbs
    # Heuristic (in order):
    # Find all verbs
    verbs = find_all_verbs(tree)
    # Mark nothing to be removed originally
    will_remove = map(lambda x: False, range(len(verbs)))
    for dep in dependencies:
        for i in range(len(verbs)):
            if (# Take both verbs from: conj_and, conj_or.  (This currently
                #   has no effect; we just interpret everything as "or".)
                False or
                # Remove all verbs that are the second argument of: advcl, aux,
                #   auxpass, csubj, csubjpass, expl, parataxis
                (dep.relation in ["advcl", "aux", "auxpass", "csubj",
                                  "csubjpass", "expl", "parataxis"] and
                 verbs[i].index == dep.dependent_index) or
                # Remove all verbs that are an argument of: mark
                (dep.relation == "mark" and
                 (verbs[i].index == dep.governor_index or
                  verbs[i].index == dep.dependent_index))):
                will_remove[i] = True
            # Look for neg where verb is the second argument to determine negations.
            elif dep.relation == "neg":
                if verbs[i].index == dep.dependent_index:
                    verbs[i].negate()
    # (End)
    # Remove marked verb elements
    iterator = range(len(verbs))
    iterator.reverse()
    for i in iterator:
        if will_remove[i]:
            verbs.pop(i)
    return verbs



def fill_empty_lexical_units(all_empty_lexical_units, msg):
    # Try to fill out the given lexical units
    all_filled_lexical_units = dict(map(lambda verb_index: [verb_index,[]],
                                        all_empty_lexical_units.keys()))
    for verb_index, empty_lexical_units in all_empty_lexical_units.items():
        for elu in empty_lexical_units:
            flu = fill_empty_lexical_unit(elu, verb_index, msg.dependencies, msg.words)
            if flu:
                all_filled_lexical_units[verb_index].append(flu)
    # See how many we filled
    num_flus = sum([len(flus)
                    for verb_index, flus
                    in all_filled_lexical_units.items()])
    return all_filled_lexical_units, num_flus


# Try filling out the lexical unit.  Return a FilledLexicalUnit, or False if not possible.
def fill_empty_lexical_unit(elu, verb_index, dependencies, words):
    flu = FilledLexicalUnit()
    flu.frame_name = elu.frame_name
    flu.verb = elu.verb
    flu.frame_elements = []
    # - Get relations from elu and dependencies from parse, and determine
    #     corresponding word for each elu relation.
    for relation in elu.frame_element_grammatical_relations:
        matches = match_dependencies([verb_index],
                                     dependencies,
                                     str.split(relation.relation, '/'))
        if matches:
            fe = FilledFrameElement()
            fe.name = relation.name
            fe.argument = words[matches[0]]
            flu.frame_elements.append(fe)
        elif relation.is_core:
            return False # We needed that relation, and we didn't have it.
    return flu


# verb_indices is listof(int)
# dependencies is listof(Dependency)
# relations_list is, eg, [num,pobj,advmod] (num of the pobj of the advmod of the verb)
# returns listof(int), the indices which match
def match_dependencies(verb_indices, dependencies, relations_list):
    def match_dependencies_recursive(word_indices, dependencies, relations_list):
        # Either we're at the end or we're out of things to search for.
        if relations_list == [] or not word_indices: return word_indices
        relation = relations_list.pop()
        matching_dependencies = filter(lambda dep:
                                           (dep.relation == relation and
                                            dep.governor_index in word_indices),
                                       dependencies)
        matching_indices = map(lambda dep: dep.dependent_index, matching_dependencies)
        return match_dependencies_recursive(matching_indices, dependencies, relations_list)
    # Clone relations list so we don't modify it.
    r = []
    r.extend(relations_list)
    return match_dependencies_recursive(verb_indices, dependencies, r)


def publish_filled_lexical_units(pub, filled_lexical_units):
    flus = FilledLexicalUnitList()
    flus.lexical_units = []
    for verb_index, filled_lexical_units in filled_lexical_units.items():
        flus.lexical_units.extend(filled_lexical_units)
    pub.publish(flus)
    return



###############################################################################
### Lexical unit storage

lexical_units = {}   # Index: string (verb) ; Element: listof(_LexicalUnit) (list of lexical units associated with a verb)

# verb is a string
# Retrives lexical unit from the database.
# Returns a listof(_LexicalUnit).  (Empty list if not found.)
def get_lexical_units(verb):
    global lexical_units
    if verb in lexical_units:
        return lexical_units[verb]
    else:
        rospy.logwarn("get_lexical_units: verb '" + verb +
                      "' not found.  (This may be normal.  Or not.)")
        return []


# Stores semantic frame in the database.
# Returns True on success and False on failure.
def store_lexical_unit(lu):
    global lexical_units
    if not isinstance(lu, _LexicalUnit):
        rospy.logerr("store_lexical_unit: Given object (" + str(lu) +
                     ") is not a _LexicalUnit object!  Ignoring request.")
        return False
    else:
        if lu.verb not in lexical_units:
            lexical_units[lu.verb] = []
        lexical_units[lu.verb].append(lu)
        rospy.loginfo("Added new lexical unit " + str(lu) + ".")
        return True


# Loads lexical unit and stores it in the database.
# Returns True on success and False on failure.
def load_lexical_unit_yaml(filename):
    global lexical_units
    try:
        lu_yaml = yaml.load(open(filename, 'r'))
    except:
        rospy.logerr("Error loading file '%s': %s" % (str(filename), str(sys.exc_info())))
        return False
    else:
        # Load multiple lexical units as a list in a single file, too.
        # result is False if one or more calls to store_lexical_unit returns False.
        rospy.loginfo("Loading lexical units from: " + filename)
        result = not sum(map(lambda lu: not store_lexical_unit(lu),
                             _LexicalUnit.import_yaml(lu_yaml)))
        if not result:
            rospy.logerr("Could not add lexical unit(s) from '" + filename + "'!")
        return result





###############################################################################
### ROS Callbacks

def cb_AddLexicalUnit(req):
    response = AddLexicalUnitResponse()
    response.success = load_lexical_unit_yaml(req.absolute_file_path)
    return response


def cb_parse(msg, pub):
    elus, num_elus = get_empty_lexical_units(msg)
    if num_elus == 0:
        rospy.logwarn("cb_parse: Did not receive any lexical units!  Aborting.")
        return
    flus, num_flus = fill_empty_lexical_units(elus, msg)
    if num_flus == 0:
        rospy.logwarn("cb_parse: Could not fill any lexical units!  Aborting.")
        return
    publish_filled_lexical_units(pub, flus)





###############################################################################
### Main

def main():
    rospy.init_node('semantic_framer')

    lu_relpath = '../lu' # relative to this binary
    lu_filenames    = filter(lambda fn: fn[-5:] == '.yaml', os.listdir(lu_relpath))
    rospy.loginfo("semantic_framer: Loading lexical units...")
    for lu_filename in lu_filenames:
        load_lexical_unit_yaml(os.path.join(lu_relpath, lu_filename))
    rospy.loginfo("semantic_framer: Done loading lexical units.")

    rospy.Service('add_lexical_unit',       AddLexicalUnit,       cb_AddLexicalUnit)
    pub = rospy.Publisher('filled_lexical_units', FilledLexicalUnitList)
    rospy.Subscriber('parse', Parse, lambda msg: cb_parse(msg, pub))
    rospy.loginfo("semantic_framer: Services up.")

    rospy.spin()

if __name__ == '__main__':
    main()