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, 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
def resolve(self, kb, event_ontology_yaml, ontology_flags): print("EventDirectionResolver RESOLVE") ontology_mapper = OntologyMapper() ontology_mapper.load_ontology(event_ontology_yaml) event_type_to_grounded_types = {} valid_directions = ["Increase", "Decrease"] for direction in valid_directions: for flag in ontology_flags.split(','): grounded_types = ontology_mapper.look_up_external_types( direction, flag) event_type_to_grounded_types.setdefault( direction, []).extend(grounded_types) resolved_kb = KnowledgeBase() super(EventDirectionResolver, self).copy_all(resolved_kb, kb) new_kb_events = [] for kb_event in resolved_kb.evid_to_kb_event.values(): kb_event_mentions = [] directions = set() for kb_event_mention in kb_event.event_mentions: groundings = [ type for type, score in kb_event_mention.external_ontology_sources ] # Avoid redundancy if any(event_type_to_grounded_types[direction] in groundings for direction in valid_directions): continue if not kb_event_mention.trigger: continue if not "direction_of_change" in kb_event_mention.properties: continue direction = kb_event_mention.properties["direction_of_change"] if direction not in valid_directions: continue directions.add(direction) event_mention_id = SharedIDManager.get_in_document_id( "EventMention", kb_event_mention.document.id) new_kb_event_mention = KBEventMention( event_mention_id, kb_event_mention.document, kb_event_mention.trigger, kb_event_mention.trigger_start, kb_event_mention.trigger_end, kb_event_mention.snippet, [], [], kb_event_mention.sentence, [], None, kb_event_mention.model, kb_event_mention.event_confidence, kb_event_mention.trigger_original_text) for grounding in event_type_to_grounded_types[direction]: new_kb_event_mention.add_or_change_grounding( grounding, kb_event_mention.get_max_grounding_confidence()) new_kb_event_mention.has_topic = kb_event_mention kb_event_mentions.append(new_kb_event_mention) if len(directions) != 1: continue event_id = SharedIDManager.get_in_document_id( "Event", new_kb_event_mention.document.id) new_kb_event = KBEvent( event_id, event_type_to_grounded_types[directions.pop()][0]) for kb_event_mention in kb_event_mentions: new_kb_event.add_event_mention(kb_event_mention) new_kb_events.append(new_kb_event) for new_kb_event in new_kb_events: resolved_kb.add_event(new_kb_event) return resolved_kb