def create_papfunc_node(cls, semantic_node, vecspace, matspace,multiply_matrices=False): ''' Create a Papfunc semantic node from a semantic node, a vector space, and a space of (flattened) matrices. An optional Boolean argument, if set to True, makes matrices to be multiplied rather than summed when both subconstituents have arity greater than 0. ''' label = semantic_node.label if semantic_node.is_terminal():#for terminal nodes perform lexical lookup word = semantic_node.word pos = semantic_node.pos if hasattr(semantic_node, "_lemma"): lemma = semantic_node.lemma papfunc_node = Papfunc_SemanticNode(label,None, word=word, pos=pos, lemma=lemma) else: papfunc_node = Papfunc_SemanticNode(label,None, word=word, pos=pos) else:# initialize a non-terminal node papfunc_node = Papfunc_SemanticNode(label,None) if semantic_node._children and not semantic_node.is_terminal(): #initialize and add each child for child in semantic_node._children: assert_type(child, SemanticNode, "argument needs to be of type SemanticNode") papfunc_child=Papfunc_SemanticNode.create_papfunc_node(child, vecspace, matspace,multiply_matrices=multiply_matrices) papfunc_node.add_child(papfunc_child) #compositionally obtain semantic representations papfunc_node.compute_matreps(vecspace,matspace,multiply_matrices=multiply_matrices) if len(papfunc_node._numrep)>0: papfunc_node.set_vector(papfunc_node._numrep[0].transpose()) return papfunc_node
def __init__(self, lambda_, lexical_space): ''' Constructor ''' super(SemanticSyntacticTreeKernel, self).__init__(lambda_) assert_type(lexical_space, Space, "lexical_space must be of type Space") self._lexical_space = lexical_space
def create_papfunc_node(cls, semantic_node, vecspace, matspace,multiply_matrices=False): ''' Create a Papfunc semantic node from a semantic node, a vector space, and a space of (flattened) matrices. An optional Boolean argument, if set to True, makes matrices to be multiplied rather than summed when both subconstituents have arity greater than 0. ''' label = semantic_node.label if semantic_node.is_terminal():#create a terminal node word = semantic_node.word pos = semantic_node.pos if hasattr(semantic_node, "_lemma"): lemma = semantic_node.lemma papfunc_node = Papfunc_SemanticNode(label,None, word=word, pos=pos, lemma=lemma) else: papfunc_node = Papfunc_SemanticNode(label,None, word=word, pos=pos) else:#initialize a nonterminal node papfunc_node = Papfunc_SemanticNode(label,None) if semantic_node._children and not semantic_node.is_terminal(): #print(semantic_node) for child in semantic_node._children: #print(child) assert_type(child, SemanticNode, "argument needs to be of type SemanticNode") papfunc_child=Papfunc_SemanticNode.create_papfunc_node(child, vecspace, matspace,multiply_matrices=multiply_matrices) #print(papfunc_child) papfunc_node.add_child(papfunc_child) #compositionally obtain semantic representations papfunc_node.compute_matreps(vecspace,matspace,multiply_matrices=multiply_matrices) # set vector attribute for non-empty elements taking the first element of # the vector-matrix structure if len(papfunc_node._numrep)>0: # compositionally derived vectors are vertical, we need to transpose them papfunc_node.set_vector(papfunc_node._numrep[0].transpose()) return papfunc_node
def __init__(self,root): '''Constructor Args: root<SyntacticNode>: the root node of the tree ''' type_utils.assert_type(root, SyntacticNode) self._root = root
def __init__(self, label, vector, *args, **kwargs): super(SemanticNode, self).__init__(label, *args, **kwargs) if vector is not None: assert_type(vector, Matrix, "argument vector needs to be of type Matrix") #set default attributes self._vector = vector self._matrep = [] self._numrep = []
def dot_product(self, tree1, tree2): assert_type(tree1, SemanticTree) assert_type(tree2, SemanticTree) sentence_vector1 = tree1._root._vector sentence_vector2 = tree2._root._vector if sentence_vector1.norm() == 0.0 or sentence_vector2.norm() == 0.0: return 0.0 else: return self._similarity.get_sim(sentence_vector1, sentence_vector2)
def add_child(self,child): """Add a child Node to a Node. Args: child: the child Node """ # check whether the child belong to the class Node type_utils.assert_type(child, Node) self._children.append(child)
def add_child(self, child): """Add a child SyntacticNode to a SyntacticNode. Args: child: the child SyntacticNode """ if self._type == SyntacticNode.TERMINAL: raise ValueError("Terminal node cannot have child node") type_utils.assert_type(child, SyntacticNode) Node.add_child(self, child)
def add_child(self, child): """Add a child SemanticNode to a SemanticNode. This method overrides the add_child method from SyntacticNode to enforce the constraint that the child parameter must be a SemanticNode Args: child: the child SemanticNode """ assert_type(child, SemanticNode) SyntacticNode.add_child(self, child)
def add_child(self, child): """Add a child Papfunc_SemanticNode to a Papfunc_SemanticNode. This method overrides the add_child method from SemanticNode to enforce the constraint that the child parameter must be a Papfunc_SemanticNode Args: child: the child Papfunc_SemanticNode """ #print ("adding child %s..." %child) assert_type(child, Papfunc_SemanticNode) SemanticNode.add_child(self, child)
def __init__(self, label, vector, *args, **kwargs): ''' Constructor Args: label<string>: the label (cat in CCG tree) of the node vector<composes.matrix.matrix.Matrix>: the vector represention of the node kwargs: see the constructor of a syntactic node ''' super(SemanticNode, self).__init__(label, *args, **kwargs) if vector is not None: assert_type(vector, Matrix, "argument vector needs to be of type Matrix") self._vector = vector
def dot_product(self, tree1, tree2): assert_type(tree1, SyntacticTree) assert_type(tree2, SyntacticTree) all_nodes1 = tree1.get_nodes() all_nodes1.reverse() all_nodes2 = tree2.get_nodes() all_nodes2.reverse() node2id1 = list2dict(all_nodes1) node2id2 = list2dict(all_nodes2) delta_matrix = -np.ones((len(all_nodes1), len(all_nodes2)), np.float) # print "\n",delta_matrix for node1 in all_nodes1: for node2 in all_nodes2: self._delta(node1, node2, node2id1, node2id2, delta_matrix) # print delta_matrix return delta_matrix.sum()
def syntactic_tree_2_semantic_tree(syntactic_tree, vector_space, composition_model, normed=True): """Create a SemanticTree from a SyntacticTree Args: syntactic_tree: the input syntatic_tree vector_space: a vector space where the lexical vectors can be retrieved composition_model: the compositional model, with which the vector representations of phrases are computed (the compositional model should be either WeightedAdditive, Multiplicative or FullAdditive) normed: a boolean value indicating whether the lexical vectors should be normalized or not Returns: the semantic tree """ assert_type(syntactic_tree, SyntacticTree) return SemanticTree(_syntactic_node_2_semantic_node(syntactic_tree._root, vector_space, composition_model, normed))
def dot_product(self, tree1, tree2): assert_type(tree1, SemanticTree) assert_type(tree2, SemanticTree) return super(MixedCompositionalTreeKernel, self).dot_product(tree1, tree2)
def lemma_tree_2_lemmapos_tree(syntactic_tree, excluded_poss = {}): assert_type(syntactic_tree, SyntacticTree) return SyntacticTree(_lemma_tree_2_lemmapos_tree(syntactic_tree._root, excluded_poss))
def __init__(self, root): ''' Constructor ''' type_utils.assert_type(root, SemanticNode) self._root = root
def dot_product(self, tree1, tree2): assert_type(tree1, SemanticTree) assert_type(tree2, SemanticTree) return super(SemanticTreeKernel, self).dot_product(tree1,tree2)