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)