Example #1
0
    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("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