Ejemplo n.º 1
0
 def treeify(parsed_dict, parent):
     for key, values in parsed_dict.items():
         key_node = pptree.Node(key, parent)
         if isinstance(values, str):
             _ = pptree.Node(values, key_node)
         else:
             treeify(values, key_node)
Ejemplo n.º 2
0
    def generate_tree_architecture(self, root_node=None):
        if root_node is None:
            the_node = pptree.Node(str(self))
        else:
            the_node = pptree.Node(str(self), root_node)

        if self.left is not None:
            self.left.generate_tree_architecture(the_node)

        if self.right is not None:
            self.right.generate_tree_architecture(the_node)

        return the_node
 def inorder(node, nnode):
     if node.isLeaf:
         newnode = pptree.Node('H', nnode)
         wnode = pptree.Node(node.word, newnode)
     elif nnode is not None:
         newnode = pptree.Node('H', nnode)
         inorder(node.left, newnode)
         inorder(node.right, newnode)
     elif node.isRoot():
         newnode = pptree.Node('H')
         inorder(node.left, newnode)
         inorder(node.right, newnode)
         return newnode
     return None
Ejemplo n.º 4
0
    def out_pptree(self, parent=None):
        """
        Recursive function
        Return instance of pptree module to print the tree

        :param parent: parent of the tree (for the recursive part of the function)
        :type parent: Node
        :return: instance of pptree.Node
        """
        name = repr(self)
        if parent:
            current = pptree.Node(name, parent)
        else:
            current = pptree.Node(name)
        for c in self.children:
            c.out_pptree(current)
        return current
def pretty_print_attention_tree(attention_list, input_tree, parent,
                                write_index, curr_index):
    """
    Display the parts of the tree focused on by the attention 
    while a particular node is being generated.
    This function was designed for the identity dataset, 
    where the input and target trees are identical.
    
    :param attention_list: a list of indices the attention focused on (preorder traversal order)
    :param input_tree: subtree we're currently processing
    :param parent: parent of the node we're currently processing
    :param write_index: node currently being created during this iteration
    :param curr_index: index of the node we're currently processing
    :returns index of one past the last node in our subtree.
    """

    # If the current node was being generated or was focused on by the attention, mark it
    root_val = str(int(target_tree.value))

    if curr_index == write_index:
        root_val = "*" + root_val + "*"
    if curr_index in attention_list:
        root_val = "(" + root_val + ")"

    # Create new node
    root_node = pptree.Node(root_val, parent)
    curr_index += 1

    # Recursively add the child subtrees to the tree.
    for child in target_tree.children:
        curr_index = pretty_print_attention_tree(attention_list, child,
                                                 root_node, write_index,
                                                 curr_index)
    if parent is None:
        pptree.print_tree(root_node)

    return curr_index
Ejemplo n.º 6
0
def parseHelper(b, sentence, p, LEX_k, project_rounds, verbose, debug,
                lexeme_dict, all_areas, explicit_areas, readout_method,
                readout_rules):
    debugger = ParserDebugger(b, all_areas, explicit_areas)

    sentence = sentence.split(" ")

    extreme_debug = False

    for word in sentence:
        lexeme = lexeme_dict[word]
        b.activateWord(LEX, word)
        if verbose:
            print("Activated word: " + word)
            print(b.areas[LEX].winners)

        for rule in lexeme["PRE_RULES"]:
            b.applyRule(rule)

        proj_map = b.getProjectMap()
        for area in proj_map:
            if area not in proj_map[LEX]:
                b.areas[area].fix_assembly()
                if verbose:
                    print("FIXED assembly bc not LEX->this area in: " + area)
            elif area != LEX:
                b.areas[area].unfix_assembly()
                b.areas[area].winners = []
                if verbose:
                    print("ERASED assembly because LEX->this area in " + area)

        proj_map = b.getProjectMap()
        if verbose:
            print("Got proj_map = ")
            print(proj_map)

        for i in range(project_rounds):
            b.parse_project()
            if verbose:
                proj_map = b.getProjectMap()
                print("Got proj_map = ")
                print(proj_map)
            if extreme_debug and word == "a":
                print("Starting debugger after round " + str(i) + "for word" +
                      word)
                debugger.run()

        #if verbose:
        #	print("Done projecting for this round")
        #	for area_name in all_areas:
        #		print("Post proj stats for " + area_name)
        #		print("w=" + str(b.areas[area_name].w))
        #		print("num_first_winners=" + str(b.areas[area_name].num_first_winners))

        for rule in lexeme["POST_RULES"]:
            b.applyRule(rule)

        if debug:
            print("Starting debugger after the word " + word)
            debugger.run()

    # Readout
    # For all readout methods, unfix assemblies and remove plasticity.
    b.no_plasticity = True
    for area in all_areas:
        b.areas[area].unfix_assembly()

    dependencies = []

    def read_out(area, mapping):
        to_areas = mapping[area]
        b.project({}, {area: to_areas})
        this_word = b.getWord(LEX)

        for to_area in to_areas:
            if to_area == LEX:
                continue
            b.project({}, {to_area: [LEX]})
            other_word = b.getWord(LEX)
            dependencies.append([this_word, other_word, to_area])

        for to_area in to_areas:
            if to_area != LEX:
                read_out(to_area, mapping)

    def treeify(parsed_dict, parent):
        for key, values in parsed_dict.items():
            key_node = pptree.Node(key, parent)
            if isinstance(values, str):
                _ = pptree.Node(values, key_node)
            else:
                treeify(values, key_node)

    if readout_method == ReadoutMethod.FIXED_MAP_READOUT:
        # Try "reading out" the parse.
        # To do so, start with final assembly in VERB
        # project VERB->SUBJ,OBJ,LEX

        parsed = {VERB: read_out(VERB, readout_rules)}

        print("Final parse dict: ")
        print(parsed)

        root = pptree.Node(VERB)
        treeify(parsed[VERB], root)

    if readout_method == ReadoutMethod.FIBER_READOUT:
        activated_fibers = b.getActivatedFibers()
        if verbose:
            print("Got activated fibers for readout:")
            print(activated_fibers)

        read_out(VERB, activated_fibers)
        print("Got dependencies: ")
        print(dependencies)