def resolve(self, kb):
print("BadRelationResolver RESOLVE")
resolved_kb = KnowledgeBase()
super(BadRelationResolver, self).copy_all(resolved_kb, kb)
resolved_kb.clear_relations_and_relation_groups()
for relid, relation in kb.get_relations():
# Always let event-event relations through
if relation.argument_pair_type == "event-event":
resolved_kb.add_relation(relation)
continue
# Entity-level arguments are the same, skip
if relation.left_argument_id == relation.right_argument_id:
#print "Skipping relation (1): " + relation.id
continue
# Cross-document entities will end up the same if the
# args have the same cameo_country_code, so skip
left_entity = kb.entid_to_kb_entity[relation.left_argument_id]
right_entity = kb.entid_to_kb_entity[relation.right_argument_id]
if (left_entity.properties.get("cameo_country_code") is not None and
right_entity.properties.get("cameo_country_code") is not None and
left_entity.properties.get("cameo_country_code") == right_entity.properties.get("cameo_country_code")):
#print "Skipping relation (2): " + relation.id
continue
resolved_kb.add_relation(relation)
return resolved_kb
def resolve(self, kb):
print("EventRemovalResolver RESOLVE")
resolved_kb = KnowledgeBase()
super(EventRemovalResolver, self).copy_all(resolved_kb, kb)
resolved_kb.clear_events_relations_and_groups()
bad_event_ids = set()
for evid, event in kb.get_events():
found_good_event_mention = False
for event_mention in event.event_mentions:
if event_mention.trigger is None or event_mention.trigger.lower() not in self.bad_trigger_words:
found_good_event_mention = True
break
if found_good_event_mention:
corrected_event = self.correct_event_type(event)
if corrected_event is not None:
resolved_kb.add_event(event)
else:
bad_event_ids.add(evid)
for relid, relation in kb.get_relations():
if relation.left_argument_id not in bad_event_ids and relation.right_argument_id not in bad_event_ids:
resolved_kb.add_relation(relation)
return resolved_kb
def resolve(self, kb):
print("RedundantEventResolver RESOLVE")
resolved_kb = KnowledgeBase()
super(RedundantEventResolver, self).copy_all(resolved_kb, kb)
resolved_kb.clear_events_relations_and_groups()
# Organize events by sentence
sentence_to_event_mention_list = dict()
event_mention_to_event = dict()
for evid, event in kb.get_events():
for event_mention in event.event_mentions:
event_mention_to_event[event_mention] = event
if event_mention.model == "ACCENT":
continue
sentence = event_mention.sentence
if sentence not in sentence_to_event_mention_list:
sentence_to_event_mention_list[sentence] = []
sentence_to_event_mention_list[sentence].append(event_mention)
event_mentions_to_remove = set()
for sentence, event_mention_list in sentence_to_event_mention_list.items(
):
# Looking at event mentions for a particular sentence
for em1 in event_mention_list:
for em2 in event_mention_list:
if em1 == em2:
continue
if em1.is_similar_and_better_than(em2):
#print "Throwing out: " + em2.id + " because it is worse than " + em1.id
event_mentions_to_remove.add(em2)
bad_event_ids = set()
for evid, event in kb.get_events():
found_good_event_mention = False
for event_mention in event.event_mentions:
if not event_mention in event_mentions_to_remove:
found_good_event_mention = True
break
if found_good_event_mention:
resolved_kb.add_event(event)
else:
bad_event_ids.add(evid)
for relid, relation in kb.get_relations():
if relation.left_argument_id not in bad_event_ids and relation.right_argument_id not in bad_event_ids:
resolved_kb.add_relation(relation)
# add event group to event mapping:
for evgid, event_group in kb.get_event_groups():
ev_group = KBEventGroup(event_group.id)
for event in event_group.members:
if event.id not in bad_event_ids:
ev_group.members.append(event)
if len(ev_group.members) > 0:
resolved_kb.add_event_group(ev_group)
return resolved_kb
def resolve(self, kb):
print("RemovalByTypeResolver RESOLVE")
resolved_kb = KnowledgeBase()
super(RemovalByTypeResolver, self).copy_all(resolved_kb, kb)
resolved_kb.clear_events_relations_and_groups()
bad_event_ids = set()
for evid, event in kb.get_events():
for event_mention in event.event_mentions:
rule_list = self.removal_info.get(event_mention.event_type)
if not rule_list:
break
for rule in rule_list:
if rule.matches_event_mention(event_mention, kb):
bad_event_ids.add(evid)
break
bad_relation_ids = set()
for relid, relation in kb.get_relations():
for relation_mention in relation.relation_mentions:
rule_list = self.removal_info.get(relation.relation_type)
if not rule_list:
break
for rule in rule_list:
if rule.matches_relation_mention(relation_mention, kb):
bad_relation_ids.add(relid)
break
# Add in non-bad events to resolved KB
for evid, event in kb.get_events():
if evid not in bad_event_ids:
resolved_kb.add_event(event)
#else:
# print "Removing: " + evid
# Add in non-bad relations that didn't have an event removed
for relid, relation in kb.get_relations():
if (relid not in bad_relation_ids
and relation.left_argument_id not in bad_event_ids
and relation.right_argument_id not in bad_event_ids):
resolved_kb.add_relation(relation)
#else:
# print "Removing: " + relid
# add event group to event mapping:
for evgid, event_group in kb.get_event_groups():
ev_group = KBEventGroup(event_group.id)
for event in event_group.members:
if event.id not in bad_event_ids:
ev_group.members.append(event)
if len(ev_group.members) > 0:
resolved_kb.add_event_group(ev_group)
return resolved_kb
def resolve(self, kb):
print("RedundantRelationResolver RESOLVE")
resolved_kb = KnowledgeBase()
super(RedundantRelationResolver, self).copy_all(resolved_kb, kb)
resolved_kb.clear_relations_and_relation_groups()
# Organize old relation mentions by sentence
sentences_to_relation_mention_list = dict()
relation_mention_to_relation = dict()
for relid, relation in kb.get_relations():
if relation.argument_pair_type != "event-event":
continue
for relation_mention in relation.relation_mentions:
relation_mention_to_relation[relation_mention] = relation
left_sentence = relation_mention.left_mention.sentence
right_sentence = relation_mention.right_mention.sentence
k = (
left_sentence,
right_sentence,
)
if k not in sentences_to_relation_mention_list:
sentences_to_relation_mention_list[k] = []
sentences_to_relation_mention_list[k].append(relation_mention)
relation_mentions_to_remove = set()
for sentence_pair, relation_mention_list in sentences_to_relation_mention_list.items(
):
# Essentially looking at the relations mentions for a particular sentence here
for rm1 in relation_mention_list:
for rm2 in relation_mention_list:
if rm1 == rm2:
continue
r1 = relation_mention_to_relation[rm1]
r2 = relation_mention_to_relation[rm2]
if rm1.is_similar_and_better_than(rm2, r1.relation_type,
r2.relation_type):
#print("Throwing out: " + rm2.id + " because it's worse than: " + rm1.id)
relation_mentions_to_remove.add(rm2)
for relid, relation in kb.get_relations():
found_good_relation_mention = False
for relation_mention in relation.relation_mentions:
if relation_mention not in relation_mentions_to_remove:
found_good_relation_mention = True
break
if found_good_relation_mention:
resolved_kb.add_relation(relation)
return resolved_kb
def resolve(self, kb, event_ontology_yaml, ontology_flags):
print("PrecisionResolver RESOLVE")
ontology_mapper = OntologyMapper()
ontology_mapper.load_ontology(event_ontology_yaml)
tmp_bad_type_and_trigger_pairs = set()
while self.bad_type_and_trigger_pairs:
line = self.bad_type_and_trigger_pairs.pop()
internal_type, trigger = line.split(' ', 1)
for flag in ontology_flags.split(','):
grounded_types = ontology_mapper.look_up_external_types(
internal_type, flag)
# print(grounded_types, internal_type)
for grounded_type in grounded_types:
tmp_bad_type_and_trigger_pairs.add(" ".join(
[grounded_type, trigger]))
self.bad_type_and_trigger_pairs = tmp_bad_type_and_trigger_pairs
resolved_kb = KnowledgeBase()
super(PrecisionResolver, self).copy_all(resolved_kb, kb)
resolved_kb.clear_events_relations_and_groups()
bad_event_ids = set()
# Bad events by trigger word
for evid, event in kb.get_events():
found_good_event_mention = False
for event_mention in event.event_mentions:
if event_mention.trigger is None or event_mention.trigger.lower(
) not in self.bad_trigger_words:
found_good_event_mention = True
break
if not found_good_event_mention:
bad_event_ids.add(evid)
# Bad events by type and trigger word
for evid, event in kb.get_events():
found_good_event_mention = False
for event_mention in event.event_mentions:
# Events can be created that have no types/external_ontology_sources,
# but they should have causal factors
if len(event_mention.external_ontology_sources) == 0 and len(
event_mention.causal_factors) > 0:
found_good_event_mention = True
break
for event_type, score in event_mention.external_ontology_sources:
if (event_mention.trigger is None or
event_type + " " + event_mention.trigger.lower()
not in self.bad_type_and_trigger_pairs):
found_good_event_mention = True
break
if not found_good_event_mention:
#print "Removing event of type: " + event_mention.event_type + " and trigger: " + event_mention.trigger.lower()
bad_event_ids.add(evid)
bad_relation_ids = set()
# Bad relations or bad triples
for relid, relation in kb.get_relations():
if relation.argument_pair_type != "event-event":
continue
found_good_relation_mention_triggers = False
found_good_relation_mention_pattern = False
found_good_relation_triple = False
for relation_mention in relation.relation_mentions:
left_em = relation_mention.left_mention
right_em = relation_mention.right_mention
left_trigger = str(left_em.trigger).lower()
right_trigger = str(right_em.trigger).lower()
left_phrase = str(
left_em.triggering_phrase if left_em.
triggering_phrase else left_em.trigger).lower().replace(
"\n", " ")
right_phrase = str(
right_em.triggering_phrase if right_em.
triggering_phrase else right_em.trigger).lower().replace(
"\n", " ")
left_trigger = re.sub('[ ]+', ' ', left_trigger)
right_trigger = re.sub('[ ]+', ' ', right_trigger)
left_phrase = re.sub('[ ]+', ' ', left_phrase)
right_phrase = re.sub('[ ]+', ' ', right_phrase)
if left_trigger + " " + right_trigger not in self.bad_trigger_word_pairs:
found_good_relation_mention_triggers = True
if "pattern" not in relation_mention.properties or relation_mention.properties[
"pattern"] not in self.bad_relation_patterns:
found_good_relation_mention_pattern = True
# check if this triple is valid
relation_type = str(relation.relation_type).lower()
triple_variation_1 = "\t".join(
[left_trigger, relation_type, right_trigger])
triple_variation_2 = "\t".join(
[left_phrase, relation_type, right_phrase])
# if "susceptibility" in triple_variation_2 or "susceptibility" in \
# triple_variation_1:
# print ""
if triple_variation_1 not in self.bad_relation_triples and triple_variation_2\
not in self.bad_relation_triples:
found_good_relation_triple = True
if not found_good_relation_mention_triggers or not found_good_relation_mention_pattern or not found_good_relation_triple:
bad_relation_ids.add(relid)
# Add in non-bad events to resolved KB
for evid, event in kb.get_events():
if evid not in bad_event_ids:
resolved_kb.add_event(event)
#else:
# print "Removing: " + evid
# Add in non-bad relations that didn't have an event removed
for relid, relation in kb.get_relations():
if (relid not in bad_relation_ids
and relation.left_argument_id not in bad_event_ids
and relation.right_argument_id not in bad_event_ids):
resolved_kb.add_relation(relation)
#else:
# print "Removing: " + relid
# add event group to event mapping:
for evgid, event_group in kb.get_event_groups():
ev_group = KBEventGroup(event_group.id)
for event in event_group.members:
if event.id not in bad_event_ids:
ev_group.members.append(event)
if len(ev_group.members) > 0:
resolved_kb.add_event_group(ev_group)
return resolved_kb
