def resolve(self, kb):
print("EventPolarityResolver RESOLVE")
resolved_kb = KnowledgeBase()
super(EventPolarityResolver, self).copy_all(resolved_kb, kb)
for evid, kb_event in resolved_kb.get_events():
for kb_event_mention in kb_event.event_mentions:
event_mention_text = kb_event_mention.trigger
should_reverse_polarity = False
tokens_in_mention = event_mention_text.split(" ")
for token in tokens_in_mention:
if token in negative_word_set and len(
tokens_in_mention) > 1:
should_reverse_polarity = True
if should_reverse_polarity is True:
for event_type, grounding in kb_event_mention.external_ontology_sources:
for negative_type_keyword in negative_type_set:
if negative_type_keyword in event_type:
should_reverse_polarity = False
if should_reverse_polarity is True:
kb_event_mention.properties["polarity"] = "Negative"
return resolved_kb
def resolve(self, kb, relation_frequency_file, event_triggers_file):
print("ConfidenceResolver RESOLVE")
# Initialize counts from trigger files
self.event_trigger_counts = dict()
etf = codecs.open(event_triggers_file, 'r', encoding='utf8')
for line in etf:
line = line.strip()
pieces = line.split(" ", 1)
if len(pieces) != 2:
print("Malformed line: " + str(line))
sys.exit(1)
count = int(pieces[0])
trigger_word = pieces[1].lower()
if trigger_word not in self.event_trigger_counts: # merge by downcased versions of trigger
self.event_trigger_counts[trigger_word] = 0
self.event_trigger_counts[trigger_word] += count
#print str(trigger_word) + ": " + str(self.event_trigger_counts[trigger_word])
etf.close()
self.relation_triple_counts = dict()
rff = codecs.open(relation_frequency_file, 'r', encoding='utf8')
for line in rff:
line = line.strip()
pieces = line.split("\t")
if len(pieces) != 3:
print("Malformed line: " + str(line))
sys.exit(1)
count_and_relation_type = pieces[0].strip()
left_trigger = pieces[1].lower().strip()
right_trigger = pieces[2].lower().strip()
pieces = count_and_relation_type.split()
if len(pieces) != 2:
print("Malformed count and relation: " +
str(count_and_relation_type))
sys.exit(1)
count = int(pieces[0])
relation_type = pieces[1].strip()
key = (
relation_type,
left_trigger,
right_trigger,
)
if key not in self.relation_triple_counts: # merge by downcased versions of triggers
self.relation_triple_counts[key] = 0
self.relation_triple_counts[key] += count
#print str(key) + ": " + str(self.relation_triple_counts[key])
rff.close()
# Resolve!
resolved_kb = KnowledgeBase()
super(ConfidenceResolver, self).copy_all(resolved_kb, kb)
for evid, event in resolved_kb.get_events():
for event_mention in event.event_mentions:
if event_mention.model == "ACCENT":
event_mention.confidence = ConfidenceResolver.CAMEO_EVENT_CONFIDENCE
# if event_mention.event_type in KBEventMention.kbp_event_types:
# event_mention.confidence = ConfidenceResolver.KBP_EVENT_CONFIDENCE
# if event_mention.model == "ACCENT":
# event_mention.confidence = ConfidenceResolver.CAMEO_EVENT_CONFIDENCE
# elif event_mention.event_type.lower() != "factor":
# # Event found by NN-event models
# event_mention.confidence = ConfidenceResolver.NN_EVENT_CONFIDENCE
# else:
# # Causal factor
# trigger = str(event_mention.trigger).lower()
# trigger_count = self.event_trigger_counts.get(trigger)
# if trigger_count is None:
# trigger_count = 0
#
# if trigger_count >= 10:
# event_mention.confidence = 0.7
# elif trigger_count >= 5:
# event_mention.confidence = 0.5
# elif trigger_count >= 2:
# event_mention.confidence = 0.3
# elif trigger_count >= 1:
# event_mention.confidence = 0.2
# else:
# event_mention.confidence = 0.1
print("event_mention.confidence 3: " +
str(event_mention.confidence))
for relid, relation in resolved_kb.get_relations():
for relation_mention in relation.relation_mentions:
if relation.argument_pair_type == "entity-entity":
relation_mention.confidence = ConfidenceResolver.SERIF_ENTITY_RELATION_CONFIDENCE
elif relation_mention.properties.get("model") == "SERIF":
relation_mention.confidence = ConfidenceResolver.SERIF_EVENT_RELATION_CONFIDENCE
elif relation_mention.properties.get("model") == "PDTB":
relation_mention.confidence = ConfidenceResolver.PDTB_RELATION_CONFIDENCE
elif "extraction_confidence" in relation_mention.properties: # set in CausalRelationReader for NN relations
relation_mention.confidence = relation_mention.properties[
"extraction_confidence"]
else:
# LearnIt
left_event_trigger = str(
relation_mention.left_mention.trigger).lower()
right_event_trigger = str(
relation_mention.right_mention.trigger).lower()
key = (
relation.relation_type,
left_event_trigger,
right_event_trigger,
)
triple_count = self.relation_triple_counts.get(key)
if triple_count is None:
triple_count = 0
if triple_count >= 10:
relation_mention.confidence = 0.7
elif triple_count >= 5:
relation_mention.confidence = 0.5
elif triple_count >= 2:
relation_mention.confidence = 0.3
elif triple_count >= 1:
relation_mention.confidence = 0.2
else:
relation_mention.confidence = 0.1
return resolved_kb
