def Rule_5(self): """ Rule 5 tries to map between adp or PART instead of verb The function activates rule 5 1. dobj (X, Y) + prep (T, X) + pobj (Z, T) appends the extracted relation to self._rule_5_list """ for vertex in self.dep_graph: if vertex.token.text in self.entity_dict: frst_edge = vertex.get_edge_by_dep("dobj") for first_edge in frst_edge: connected_vertex = first_edge.target scnd_edge = vertex.get_edge_by_dep("prep") first_connector = connected_vertex.token if is_verb(connected_vertex.token) or is_adp( connected_vertex.token): for second_edge in scnd_edge: connected_vertex = second_edge.target prep_edge = connected_vertex.get_edge_by_dep( "pobj") second_connector = connected_vertex.token # if is_verb(connected_vertex.token) or is_adp(connected_vertex.token) or is_part( # TODO: test verb removed from if if is_adp(connected_vertex.token) or is_part( connected_vertex.token): for third_edge in prep_edge: if third_edge.target.token.text in self.entity_dict.keys( ): connected = get_token_from_span( self.entity_dict[ third_edge.target.token.text], third_edge.target.token) else: connected = third_edge.target.token first_ent = get_token_from_span( self.entity_dict[vertex.token.text], vertex.token) relation = Relation( first_ent, connected, second_connector, first_connector=first_connector) if not self.find_relation(relation): # print("************** Rule 5 ACTIVATED **************") # print(relation) self._rule_5_list.append(relation) self.relation_list.append(relation) self.add_to_relation_graph( first_ent=first_ent, connected_vertex=second_connector, connected=connected, first_connector=first_connector)
def Rule_1(self): """ The function activates Rule 1 prep (X,Y) + pobj (Y,Z) appends the extracted relation to self._rule_1_list """ for vertex in self.dep_graph: if vertex.token.text in self.entity_dict: prep_edge = vertex.get_edge_by_dep("prep") for edge in prep_edge: connected_vertex = edge.target second_edge = connected_vertex.get_edge_by_dep("pobj") for curr_edge in second_edge: if is_verb(connected_vertex.token) or is_adp(connected_vertex.token) or \ is_adv(connected_vertex.token): # TODO: RULE 1 ADVERB connected = self.get_current_connected(curr_edge) first_ent = get_token_from_span( self.entity_dict[vertex.token.text], vertex.token) relation = Relation(first_ent, connected, connected_vertex.token) self.relation_list.append(relation) self.add_to_relation_graph( first_ent=first_ent, connected_vertex=connected_vertex.token, connected=connected) self._rule_1_list.append(relation) print( "************** Rule 1 ACTIVATED **************" ) print(relation)
def get_current_connected(self, prep_edge): """ The functions tries to find an edge target in entity dict :param prep_edge: :return: token from entity dict if edge target exists there """ if prep_edge.target.token.text in self.entity_dict.keys(): return get_token_from_span( self.entity_dict[prep_edge.target.token.text], prep_edge.target.token) else: return prep_edge.target.token
def Rule4(self): """ The function activates Rule 4 1. xcomp (X,Y) + dobj (Y,Z) appends the extracted relation to self._rule_4_list """ for vertex in self.dep_graph: prep_edge = vertex.get_edge_by_dep("xcomp") for first_edge in prep_edge: connected_vertex = first_edge.target scnd_edge = connected_vertex.get_edge_by_dep("dobj") if is_verb(connected_vertex.token) or is_adp( connected_vertex.token): for second_edge in scnd_edge: if second_edge.target.token.text in self.entity_dict.keys( ): connected = get_token_from_span( self.entity_dict[ second_edge.target.token.text], second_edge.target.token) else: connected = second_edge.target.token if vertex.token.text in self.entity_dict.keys(): connected2 = get_token_from_span( self.entity_dict[vertex.token.text], vertex.token) else: connected2 = vertex.token relation = Relation(connected_vertex.token, connected, connected2) self._rule_4_list.append(relation) self.relation_list.append(relation) self.add_to_relation_graph( first_ent=connected_vertex.token, connected_vertex=connected, connected=connected2)
def Rule_2(self): """ Rule 2 infers to vern and noun modifiers The function activates Rule 2 1. acl (X,Y) + dobj (Y,Z) 2. advcl (X,Y) + dobj (Y,Z) 3. nsubj (X,Y) + dobj(Y,Z) 4. relcl (X,Y) + dobj(Y,Z) appends the extracted relation to self._rule_2_list """ for vertex in self.dep_graph: if vertex.token.text in self.entity_dict: prep_edge = rule_2_edge(vertex) for edge in prep_edge: connected_vertex = edge.target scnd_edge = connected_vertex.get_edge_by_dep("dobj") for second_edge in scnd_edge: if is_verb(connected_vertex.token) or is_adp( connected_vertex.token): first_ent = get_token_from_span( self.entity_dict[vertex.token.text], vertex.token) connected = self.get_current_connected(second_edge) second_ent = connected # second_ent = get_token_from_span(self.entity_dict[prep_edge.target.token.text], # prep_edge.target.token) # relation = Relation(self.entity_dict[vertex.token.text], # self.entity_dict[prep_edge.target.token.text], # connected_vertex.token) relation = Relation(first_ent, second_ent, connected_vertex.token) self.relation_list.append(relation) self._rule_2_list.append(relation) self.add_to_relation_graph( first_ent=first_ent, connected_vertex=connected_vertex.token, connected=connected) print( "************** Rule 2 ACTIVATED **************" ) print(relation)
def rule_3_it(self, prep_edge=None, connected_vertex=None, vertex=None, first_connector=None, second_connector=None): """ The function iterates over rule 3 extractions and finds more complicated rules 1. dobj (X,Y) + xcomp (Y,Z) + aux (T,Z) + prep (Z, Q) 1. dobj (X,Y) + xcomp (Y,Z) + aux (T,Z) + dobj (Z, Q) 3. dobj (X,Y) + prep (Y,Z) + pcomp (T,Z) + dobj (Z, Q) :param prep_edge: edge to explore in the dependency graph :param connected_vertex: connected vertex represents the connected token on relation :param vertex: current vertex we are exploring :param first_connector: first connector between entities :param second_connector: second connector between entities """ # TODO: test it! if prep_edge is not None \ and (is_verb(connected_vertex.token) or is_adp(connected_vertex.token) or is_part(connected_vertex.token)): connected = self.get_current_connected(prep_edge) first_ent = get_token_from_span( self.entity_dict[vertex.token.text], vertex.token) if prep_edge.dependency == 'aux': prep_edge = connected_vertex.get_edge_by_dep('prep') if not prep_edge: prep_edge = connected_vertex.get_edge_by_dep('dobj') for to_prep_edge in prep_edge: self.rule_3_to(to_prep_edge, connected_vertex, first_ent, first_connector, connected) return # handle pcomp elif prep_edge.dependency == 'pcomp': edge = prep_edge.target.get_edge_by_dep('dobj') for pcomp_edge in edge: self.rule_3_to(pcomp_edge, connected_vertex, first_ent, first_connector, connected) return self.add_to_rule_3(first_ent, connected, second_connector, first_connector)
def Rule_small(self): """ The function handles small rules who didn't get any relation before 1. dobj (X, Y) """ if not self.find_no_extracted_relation( ): # test if no relation has been extracted return for vertex in self.dep_graph: if vertex.token.text in self.entity_dict: edge_list = vertex.get_edge_by_dep("dobj") for edge in edge_list: connected_vertex = edge.target if not is_verb(connected_vertex.token): continue first_ent = get_token_from_span( self.entity_dict[vertex.token.text], vertex.token) relation = Relation(token=first_ent, first_connector=connected_vertex.token) self._small_rule_list.append(relation) self.relation_list.append(relation) self.add_to_relation_graph( first_ent=first_ent, first_connector=connected_vertex.token)