def test_create_a_relation_argument_add_attribute(self): #g = get_initialized_graph() g = aifutils.make_graph() # every AIF needs an object for the system responsible for creating it system = aifutils.make_system_with_uri( g, "http://www.test.edu/testSystem") bob = aifutils.make_entity(g, "http://www.test.edu/entites/person/Bob", system) maryland = aifutils.make_entity( g, "http://www.test.edu/entites/place/Maryland", system) aifutils.mark_type(g, "http://www.test.edu/assertions/bobIsAPerson", bob, ldc_ontology.PER, system, 1.0) aifutils.mark_type( g, "http://www.test.edu/assertions/marylandIsALocation", maryland, ldc_ontology.LOC_Position_Region, system, 1.0) # we make a resource for the event itself relationBobLiveInMD = aifutils.make_relation( g, "http://www.test.edu/relationss/bobLivesInMaryland", system) argument1 = aifutils.mark_as_argument( g, relationBobLiveInMD, ldc_ontology.Physical_Resident_Resident, bob, system, 1) aifutils.mark_attribute(g, argument1, interchange_ontology.Generic) self.new_file(g, "test_create_a_relation_argument_add_attribute.ttl") self.dump_graph( g, "Invalid: Relation Argument cannot have aida:Attribute")
def test_create_an_event_with_ldc_time(self): g = aifutils.make_graph() g.bind('ldcOnt', SEEDLING_TYPES_NIST.uri) # every AIF needs an object for the system responsible for creating it system = aifutils.make_system_with_uri( g, "http://www.test.edu/testSystem") # create a start position event with unknown start and end time event_start_position = aifutils.make_event( g, "http://www.test.edu/event/1", system) aifutils.mark_type(g, "http://www.test.edu/assertions/1", event_start_position, SEEDLING_TYPES_NIST['Personnel.StartPosition'], system, 1.0) unknown = LDCTimeComponent(LDCTimeType.UNKNOWN, None, None, None) endBefore = LDCTimeComponent(LDCTimeType.BEFORE, "2016", None, None) aifutils.mark_ldc_time(g, event_start_position, unknown, endBefore, system) # create an attack event with an unknown start date, but definite end date event_attack_unknown = aifutils.make_event( g, "http://www.test.edu/event/2", system) aifutils.mark_type(g, "http://www.test.edu/assertions/2", event_attack_unknown, SEEDLING_TYPES_NIST['Conflict.Attack'], system, 1.0) start = LDCTimeComponent(LDCTimeType.AFTER, "2014", "--02", None) end = LDCTimeComponent(LDCTimeType.ON, "2014", "--02", "---21") aifutils.mark_ldc_time(g, event_attack_unknown, start, end, system) self.new_file(g, "test_create_an_event_with_ldc_time.ttl") self.dump_graph(g, "create an event with LDCTime")
def test_create_an_entity_with_add_invalid_attribute(self): #g = get_initialized_graph() g = aifutils.make_graph() # every AIF needs an object for the system responsible for creating it system = aifutils.make_system_with_uri( g, "http://www.test.edu/testSystem") # it doesn't matter what URI we give entities, events, etc. so long as they are # unique entity = aifutils.make_entity(g, "http://www.test.edu/entities/1", system) aifutils.mark_attribute(g, entity, interchange_ontology.Irrealis) aifutils.mark_attribute(g, entity, interchange_ontology.Negated) aifutils.mark_attribute(g, entity, interchange_ontology.Hedged) aifutils.mark_attribute( g, entity, interchange_ontology.VideoJustificationChannelPicture) self.new_file(g, "test_create_an_entity_with_add_invalid_attribute.ttl") self.dump_graph( g, "Invalid: Semantic Attribute for Entity can only be must be aida:Generic" )
def test_create_an_entity_with_uncertainty_about_its_type(self): g = aifutils.make_graph() g.bind('ldcOnt', SEEDLING_TYPES_NIST.uri) # every AIF needs an object for the system responsible for creating it system = aifutils.make_system_with_uri( g, "http://www.test.edu/testSystem") entity = aifutils.make_entity(g, "http://www.test.edu/entities/1", system) entity_is_a_person = aifutils.mark_type( g, "http://www.test.org/assertions/1", entity, SEEDLING_TYPES_NIST.Person, system, 0.5) entity_is_an_organization = aifutils.mark_type( g, "http://www.test.org/assertions/2", entity, SEEDLING_TYPES_NIST.Organization, system, 0.2) aifutils.mark_text_justification(g, [entity, entity_is_a_person], "NYT_ENG_201181231", 42, 143, system, 0.6) aifutils.mark_text_justification(g, [entity, entity_is_an_organization], "NYT_ENG_201181231", 343, 367, system, 0.3) aifutils.mark_as_mutually_exclusive( g, { tuple([entity_is_a_person]): 0.5, tuple([entity_is_an_organization]): 0.2 }, system, None) self.new_file( g, "test_create_an_entity_with_uncertainty_about_its_type.ttl") self.dump_graph(g, "Example of entity with uncertainty about type")
def test_create_seedling_entity_with_alternate_names(self): g = aifutils.make_graph() # every AIF needs an object for the system responsible for creating it system = aifutils.make_system_with_uri( g, "http://www.test.edu/testSystem") entity = aifutils.make_entity(g, "http://www.test.edu/entities/1", system) # in order to allow uncertainty about the type of an entity, we don't mark an entity's type directly on the # entity, but rather make a separate assertion for it. type_assertion = aifutils.mark_type( g, "http://www.test.org/assertions/1", entity, SEEDLING_TYPES_NIST.Person, system, 1.0) # This is just a test to make sure that validation works for the different # mark types. Rare that you would have all three with a single entity. aifutils.mark_name(g, entity, "Name One") aifutils.mark_name(g, entity, "N. One") aifutils.mark_name(g, entity, "N-Money") aifutils.mark_text_value(g, entity, "TextValue") aifutils.mark_numeric_value_as_double(g, entity, 100) aifutils.mark_numeric_value_as_long(g, entity, 100) aifutils.mark_numeric_value_as_string(g, entity, "100") self.new_file( g, "test_create_a_seedling_entity_with_alternate_names.ttl") self.dump_graph(g, "Example of seedling entity with alternate names")
def test_create_a_simple_cluster_with_handle(self): g = aifutils.make_graph() g.bind('ldcOnt', SEEDLING_TYPES_NIST.uri) # every AIF needs an object for the system responsible for creating it system = aifutils.make_system_with_uri( g, 'http://www.test.edu/testSystem') # Two people, probably the same person vladimir_putin = aifutils.make_entity( g, "http://www.test.edu/entities/1", system) aifutils.mark_type(g, "http://www.test.edu/assertions/1", vladimir_putin, SEEDLING_TYPES_NIST.Person, system, 1.0) aifutils.mark_name(g, vladimir_putin, "Vladimir Putin") putin = aifutils.make_entity(g, "http://www.test.edu/entities/2", system) aifutils.mark_type(g, "http://www.test.edu/assertions/2", putin, SEEDLING_TYPES_NIST.Person, system, 1.0) aifutils.mark_name(g, putin, "Путин") # create a cluster with prototype putin_cluster = aifutils.make_cluster_with_prototype( g, "http://www.test.edu/clusters/1", vladimir_putin, system, "Vladimir Putin") # person 1 is definitely in the cluster, person 2 is probably in the cluster aifutils.mark_as_possible_cluster_member(g, putin, putin_cluster, 0.71, system) self.new_file(g, "test_create_a_simple_cluster_with_handle.ttl") self.dump_graph(g, "create a simple cluster with handle")
def test_event_missing_type(self): # having mulitple type assertions in case of uncertainty is ok, but there must always be at # least one type assertion g = aifutils.make_graph() system = aifutils.make_system_with_uri( g, "http://www.test.edu/testSytem") aifutils.make_event(g, "http://www.test.edu/events/1", system) self.dump_graph(g, "Invalid: Event missing type")
def test_make_entity(self): g = make_graph() system = make_system_with_uri(g, "http://www.test.edu/system") entity = make_entity(g, "http://www.test.edu/entities/1", system) type_assertion = mark_type(g, "http://www.test.edu/assertions/1", entity, AIDA_PROGRAM_ONTOLOGY.Person, system, 1.0) mark_text_justification(g, [entity, type_assertion], "NYT_ENG_20181231", 42, 143, system, 0.973) self.dump_graph(g, "Example of creating an entity") self.assertEqual([type_assertion], get_type_assertions(g, entity))
def test_create_an_event_argument_add_invalid_attribute(self): #g = get_initialized_graph() g = aifutils.make_graph() # every AIF needs an object for the system responsible for creating it system = aifutils.make_system_with_uri( g, "http://www.test.edu/testSystem") # we make a resource for the event itself event = aifutils.make_event(g, "http://www.test.edu/events/1", system) # mark the event as a Personnel.Elect event; type is encoded separately so we can express # uncertainty about type aifutils.mark_type(g, "http://www.test.edu/assertions/5", event, ldc_ontology.Personnel_Elect, system, 1.0) # create the two entities involved in the event electee = aifutils.make_entity(g, "http://www.test.edu/entities/1", system) aifutils.mark_type(g, "http://www.test.edu/assertions/6", electee, ldc_ontology.PER, system, 1.0) election_country = aifutils.make_entity( g, "http://www.test.edu/entities/2", system) aifutils.mark_type(g, "http://www.test.edu/assertions/7", election_country, ldc_ontology.GPE, system, 1.0) # link those entities to the event argument1 = aifutils.mark_as_argument( g, event, ldc_ontology.Personnel_Elect_Candidate, electee, system, 0.785) argument2 = aifutils.mark_as_argument( g, event, ldc_ontology.Personnel_Elect_Place, election_country, system, 0.589) aifutils.mark_attribute(g, argument1, interchange_ontology.Irrealis) aifutils.mark_attribute(g, argument1, interchange_ontology.Generic) aifutils.mark_attribute( g, argument2, interchange_ontology.VideoJustificationChannelPicture) aifutils.mark_attribute( g, argument2, interchange_ontology.VideoJustificationChannelSound) self.new_file( g, "test_create_an_event_argument_add_invalid_attribute.ttl") self.dump_graph( g, "Invalid: Semantic Attribute for Event Argument, must be aida:Negated, aida:Hedged" )
def test_create_an_entity_with_information_justification(self): g = aifutils.make_graph() g.bind('ldcOnt', SEEDLING_TYPES_NIST.uri) # every AIF needs an object for the system responsible for creating it system = aifutils.make_system_with_uri( g, 'http://www.test.edu/testSystem') # Two people, probably the same person vladimir_putin = aifutils.make_entity( g, "http://www.test.edu/entities/1", system) aifutils.mark_name(g, vladimir_putin, "Vladimir Putin") type_assertion = aifutils.mark_type( g, "http://www.test.org/assertions/1", vladimir_putin, SEEDLING_TYPES_NIST.Person, system, 1.0) text_justification_1 = aifutils.mark_text_justification( g, [vladimir_putin, type_assertion], "HC00002Z0", 0, 10, system, 1.0) aifutils.mark_informative_justification(g, vladimir_putin, text_justification_1) putin = aifutils.make_entity(g, "http://www.test.edu/entities/2", system) aifutils.mark_type(g, "http://www.test.edu/assertions/2", putin, SEEDLING_TYPES_NIST.Person, system, 1.0) aifutils.mark_name(g, putin, "Путин") # create a cluster with prototype putin_cluster = aifutils.make_cluster_with_prototype( g, "http://www.test.edu/clusters/1", vladimir_putin, system, "Vladimir Putin") text_justification_2 = aifutils.mark_text_justification( g, [putin, type_assertion], "HC00002Z0", 0, 10, system, 1.0) aifutils.mark_informative_justification(g, putin_cluster, text_justification_2) # person 1 is definitely in the cluster, person 2 is probably in the cluster aifutils.mark_as_possible_cluster_member(g, putin, putin_cluster, 0.71, system) self.new_file( g, "test_create_an_entity_and_cluster_with_informative_mention.ttl") self.dump_graph( g, "create an entity and cluster with informative mention")
def test_make_entity(self): g = aifutils.make_graph() system = aifutils.make_system_with_uri(g, "http://www.test.edu/system") entity = aifutils.make_entity(g, "http://www.test.edu/entities/1", system) type_assertion = aifutils.mark_type( g, "http://www.test.edu/assertions/1", entity, SEEDLING_TYPES_NIST.Person, system, 1.0) aifutils.mark_text_justification(g, [entity, type_assertion], "NYT_ENG_20181231", 42, 143, system, 0.973) self.new_file(g, "test_make_an_entity.ttl") self.dump_graph(g, "Example of creating an entity") self.assertEqual([type_assertion], aifutils.get_type_assertions(g, entity))
def test_confidence_outside_of_zero_one(self): g = aifutils.make_graph() system = aifutils.make_system_with_uri(g, "http://test.edu/testSystem") entity = aifutils.make_entity(g, "http://www.test.edu/entities/1", system) aifutils.mark_type( g, "http://www.test.org/assertions/1", #illegal confidence value - not in [0.0, 1.0] entity, AIDA_PROGRAM_ONTOLOGY.Person, system, 100.0) self.dump_graph(g, "Invalid: Confidence outside of zero to one")
def test_non_type_used_as_type(self): g = aifutils.make_graph() system = aifutils.make_system_with_uri( g, "http://www.test.edu/testSystem") entity = aifutils.make_entity(g, "http://www.test.edu/entities/1", system) aifutils.mark_type( g, "http://www.test.edu/typeAssertion/1", entity, # use a blank node as teh bogus entity type BNode(), system, 1.0) self.dump_graph(g, "Invalid: Non type used as type")
def test_create_an_entity_with_image_justification_and_vector(self): g = aifutils.make_graph() g.bind('ldcOnt', SEEDLING_TYPES_NIST.uri) # every AIF needs an object for the system responsible for creating it system = aifutils.make_system_with_uri( g, "http://www.test.edu/testSystem") # it doesn't matter what URI we give entities, events, etc. so long as they are # unique entity = aifutils.make_entity(g, "http://www.test.edu/entities/1", system) # in order to allow uncertainty about the type of an entity, we don't mark an # entity's type directly on the entity, but rather make a separate assertion for it # its URI doesn't matter either type_assertion = aifutils.mark_type( g, "http://www.test.org/assertions/1", entity, SEEDLING_TYPES_NIST.Person, system, 1.0) # the justification provides the evidence for our claim about the entity's type # we attach this justification to both the type assertion and the entity object # itself, since it provides evidence both for the entity's existence and its type. # in TA1 -> TA2 communications, we attach confidences at the level of justifications # let's suppose we also have evidence from an image bb1 = Bounding_Box((123, 45), (167, 98)) aifutils.mark_image_justification(g, [entity, type_assertion], "NYT_ENG_20181231_03", bb1, system, 0.123) # also we can link this entity to something in an external KB aifutils.link_to_external_kb(g, entity, "freebase.FOO", system, .398) vec = { "vector_type": "http://www.test.edu/systemX/personVector", "vector_data": [2.0, 7.5, 0.2, 8.1] } # let's mark our entity with some arbitrary system-private data. You can attach such data # to nearly anything aifutils.mark_private_data_with_vector(g, entity, system, vec) self.new_file( g, "test_create_an_entity_with_image_justification_and_vector.ttl") self.dump_graph( g, "Example of entity with image justification and vector")
def test_create_an_event_add_invalid_attribute(self): #g = get_initialized_graph() g = aifutils.make_graph() # every AIF needs an object for the system responsible for creating it system = aifutils.make_system_with_uri( g, "http://www.test.edu/testSystem") # we make a resource for the event itself event = aifutils.make_event(g, "http://www.test.edu/events/1", system) aifutils.mark_attribute( g, event, interchange_ontology.VideoJustificationChannelPicture) self.new_file(g, "test_create_an_event_add_invalid_attribute.ttl") self.dump_graph( g, "Invalid: Semantic Attribute for Event, must be aida:Negated, aida:Hedged, aida:Irrealis, aida:Generic" )
def test_justification_missing_confidence(self): g = aifutils.make_graph() system = aifutils.make_system_with_uri(g, "http://test.edu/testSystem") entity = aifutils.make_entity(g, "http://www.test.edu/events/1", system) # create justification without the required confidence justification = BNode() g.add((justification, RDF.type, AIDA_ANNOTATION.TextJustification)) g.add((justification, AIDA_ANNOTATION.source, Literal("FOO", datatype=XSD.string))) g.add((justification, AIDA_ANNOTATION.startOffset, Literal(14, datatype=XSD.integer))) g.add((justification, AIDA_ANNOTATION.endOffsetInclusive, Literal(56, datatype=XSD.integer))) g.add((justification, AIDA_ANNOTATION.system, system)) g.add((entity, AIDA_ANNOTATION.justifiedBy, justification)) self.dump_graph(g, "Invalid: Justification missing confidence")
def test_create_a_relation_add_invalid_attribute(self): #g = get_initialized_graph() g = aifutils.make_graph() # every AIF needs an object for the system responsible for creating it system = aifutils.make_system_with_uri( g, "http://www.test.edu/testSystem") # we make a resource for the event itself relation = aifutils.make_relation( g, "https://github.com/NextCenturyCorporation/AIDA-Interchange-Format/LdcAnnotations#R779959.00004", system) aifutils.mark_attribute( g, relation, interchange_ontology.VideoJustificationChannelPicture) self.new_file(g, "test_create_a_relation_add_invalid_attribute.ttl") self.dump_graph( g, "Invalid: Semantic Attribute for Relation, must be aida:Negated, aida:Hedged, aida:Irrealis, aida:Generic" )
def test_create_seedling_event_with_event_argument_uri(self): g = aifutils.make_graph() # every AIF needs an object for the system responsible for creating it system = aifutils.make_system_with_uri( g, "http://www.test.edu/testSystem") # we make a resource for the event itself event = aifutils.make_event(g, "http://www.test.edu/events/1", system) # mark the event as a Personnel.Elect event; type is encoded separately so we can express # uncertainty about type event_type_string = "Personnel.Elect" aifutils.mark_type(g, "http://www.test.edu/assertions/5", event, SEEDLING_TYPES_NIST[event_type_string], system, 1.0) # create the two entities involved in the event electee = aifutils.make_entity(g, "http://www.test.edu/entities/1", system) aifutils.mark_type(g, "http://www.test.edu/assertions/7", electee, SEEDLING_TYPES_NIST.Person, system, 1.0) election_country = aifutils.make_entity( g, "http://www.test.edu/entities/2", system) aifutils.mark_type(g, "http://www.test.edu/assertions/7", election_country, SEEDLING_TYPES_NIST.GeopoliticalEntity, system, 1.0) # link those entities to the event aifutils.mark_as_argument( g, event, SEEDLING_TYPES_NIST[event_type_string] + "_Elect", electee, system, .785, "http://www.test.edu/eventArgument/1") aifutils.mark_as_argument( g, event, SEEDLING_TYPES_NIST[event_type_string] + "_Place", election_country, system, .589, "http://www.test.edu/eventArgument/2") self.new_file( g, "test_create_seedling_event_with_event_argument_uri.ttl") self.dump_graph(g, "Example of seedling event with event assertion URI")
def test_create_a_cluster_with_link_and_confidence(self): g = aifutils.make_graph() g.bind('ldcOnt', SEEDLING_TYPES_NIST.uri) # every AIF needs an object for the system responsible for creating it system = aifutils.make_system_with_uri( g, "http://www.test.edu/testSystem") putin = aifutils.make_entity(g, "http://www.test.edu/entities/1", system) aifutils.mark_type(g, "http://www.test.edu/assertions/1", putin, SEEDLING_TYPES_NIST.Person, system, 1.0) aifutils.mark_name(g, putin, "Путин") vladimir_putin = aifutils.make_entity( g, "http://www.test.edu/entities/2", system) aifutils.mark_type(g, "http://www.test.edu/assertions/2", vladimir_putin, SEEDLING_TYPES_NIST.Person, system, 1.0) aifutils.mark_name(g, vladimir_putin, "Vladimir Putin") # create a cluster with prototype putin_cluster = aifutils.make_cluster_with_prototype( g, "http://www.test.edu/clusters/1", vladimir_putin, system, "Vladimir Putin") # person 1 is definitely in the cluster, person 2 is probably in the cluster aifutils.mark_as_possible_cluster_member(g, putin, putin_cluster, 1.0, system) aifutils.mark_as_possible_cluster_member(g, vladimir_putin, putin_cluster, 0.71, system) # also we can link this entity to something in an external KB aifutils.link_to_external_kb(g, putin_cluster, "freebase.FOO", system, .398) self.new_file(g, "test_create_a_cluster_with_link_and_confidence.ttl") self.dump_graph(g, "create a cluster with link and confidence")
def test_create_an_event(self): g = aifutils.make_graph() g.bind('ldcOnt', SEEDLING_TYPES_NIST.uri) # every AIF needs an object for the system responsible for creating it system = aifutils.make_system_with_uri( g, "http://www.test.edu/testSystem") # we make a resource for the event itself event = aifutils.make_event(g, "http://www.test.edu/events/1", system) # mark the event as a Personnel.Elect event; type is encoded separately so we can express # uncertainty about type aifutils.mark_type(g, "http://www.test.edu/assertions/5", event, SEEDLING_TYPES_NIST['Personnel.Elect'], system, 1.0) # create the two entities involved in the event electee = aifutils.make_entity(g, "http://www.test.edu/entities/1", system) aifutils.mark_type(g, "http://www.test.edu/assertions/6", electee, SEEDLING_TYPES_NIST.Person, system, 1.0) election_country = aifutils.make_entity( g, "http://www.test.edu/entities/2", system) aifutils.mark_type(g, "http://www.test.edu/assertions/7", election_country, SEEDLING_TYPES_NIST.GeopoliticalEntity, system, 1.0) # link those entities to the event arg = URIRef(SEEDLING_TYPES_NIST['Personnel.Elect'] + "_Elect") aifutils.mark_as_argument(g, event, arg, electee, system, 0.785) arg2 = URIRef(SEEDLING_TYPES_NIST['Personnel.Elect'] + "_Place") aifutils.mark_as_argument(g, event, arg2, election_country, system, 0.589) self.new_file(g, "test_create_an_event.ttl") self.dump_graph(g, "Example of creating an event")
def test_create_a_relation_between_two_entities_where_there_is_uncertainty_about_identity_of_one_argument( self): g = aifutils.make_graph() g.bind('ldcOnt', SEEDLING_TYPES_NIST.uri) # every AIF needs an object for the system responsible for creating it system = aifutils.make_system_with_uri( g, "http://www.test.edu/testSystem") # we want to represent a "city_of_birth" relation for a person, but we aren't sure whether # they were born in Louisville or Cambridge person_entity = aifutils.make_entity(g, "http://www.test.edu/entities/1", system) aifutils.mark_type(g, "http://www.test.org/assertions/1", person_entity, SEEDLING_TYPES_NIST.Person, system, 1.0) # create entities for the two locations louisville_entity = aifutils.make_entity(g, "http://test.edu/entities/2", system) aifutils.mark_type(g, "http://www.test.org/assertions/2", louisville_entity, SEEDLING_TYPES_NIST.GeopoliticalEntity, system, 1.0) cambridge_entity = aifutils.make_entity(g, "http://test.edu/entities/3", system) aifutils.mark_type(g, "http://www.test.org/assertions/3", cambridge_entity, SEEDLING_TYPES_NIST.GeopoliticalEntity, system, 1.0) # create an entity for the uncertain place of birth uncertain_place_of_birth_entity = aifutils.make_entity( g, "http://www.test.edu/entities/4", system) # whatever this place turns out to refer to, we're sure it's where they live aifutils.make_relation_in_event_form( g, "http://test.edu/relations/1", SEEDLING_TYPES_NIST['Physical.Resident'], SEEDLING_TYPES_NIST['Physical.Resident'] + '_Resident', person_entity, SEEDLING_TYPES_NIST['Physical.Resident'] + '_Place', uncertain_place_of_birth_entity, "http://www.test.edu/assertions/4", system, 1.0) # we use clusters to represent uncertainty about identity # we make two clusters, one for Louisville and one for Cambridge louisville_cluster = aifutils.make_cluster_with_prototype( g, "http://www.test.edu/clusters/1", louisville_entity, system) cambridge_cluster = aifutils.make_cluster_with_prototype( g, "http://www.test.edu/clusters/2", cambridge_entity, system) # the uncertain place of birth is either Louisville or Cambridge place_of_birth_in_louisville_cluster = aifutils.mark_as_possible_cluster_member( g, uncertain_place_of_birth_entity, louisville_cluster, 0.4, system) place_of_birth_in_cambridge_cluster = aifutils.mark_as_possible_cluster_member( g, uncertain_place_of_birth_entity, cambridge_cluster, 0.6, system) # but not both aifutils.mark_as_mutually_exclusive( g, { tuple([place_of_birth_in_cambridge_cluster]): 0.4, tuple([place_of_birth_in_louisville_cluster]): 0.6 }, system, None) self.new_file( g, "test_create_a_relation_between_two_entities_where_there_is_uncertainty_about_identity_of_one_argument.ttl" ) self.dump_graph( g, "Relation between two entities with uncertainty about id of one")
def test_two_hypotheses(self): g = aifutils.make_graph() g.bind('ldcOnt', SEEDLING_TYPES_NIST.uri) # every AIF needs an object for the system responsible for creating it system = aifutils.make_system_with_uri( g, "http://www.test.edu/testSystem") # we want to represent that we know, regardless of hypothesis, that there is a person named Bob, # two companies (Google and Amazon), and two places (Seattle and California) bob = aifutils.make_entity(g, "http://www.test.edu/entites/Bob", system) aifutils.mark_type(g, "http://www.test.org/assertions/1", bob, SEEDLING_TYPES_NIST.Person, system, 1.0) google = aifutils.make_entity(g, "http://www.test.edu/entities/Google", system) aifutils.mark_type(g, "http://www.test.org/assertions/2", google, SEEDLING_TYPES_NIST.Organization, system, 1.0) amazon = aifutils.make_entity(g, "http://www.test.edu/entities/Amazon", system) aifutils.mark_type(g, "http://www.test.org/assertions/3", amazon, SEEDLING_TYPES_NIST.Organization, system, 1.0) seattle = aifutils.make_entity(g, "http://www.test.edu/entities/Seattle", system) aifutils.mark_type(g, "http://www.test.org/assertions/4", seattle, SEEDLING_TYPES_NIST.GeopoliticalEntity, system, 1.0) california = aifutils.make_entity( g, "http://www.test.edu/entities/California", system) aifutils.mark_type(g, "http://www.test.org/assertions/5", california, SEEDLING_TYPES_NIST.GeopoliticalEntity, system, 1.0) city_relation_subject = SEEDLING_TYPES_NIST[ 'Physical.Resident'] + '_Resident' city_relation_object = SEEDLING_TYPES_NIST[ 'Physical.Resident'] + '_Place' employee_relation_subject = SEEDLING_TYPES_NIST[ 'OrganizationAffiliation.EmploymentMembership'] + '_Employee' employee_relation_object = SEEDLING_TYPES_NIST[ 'OrganizationAffiliation.EmploymentMembership'] + '_Organization' # under the background hypothesis that Bob lives in Seattle, we believe he works for Amazon bob_lives_in_seattle = aifutils.make_relation_in_event_form( g, "http://www.test.edu/relations/1", SEEDLING_TYPES_NIST['Physical.Resident'], city_relation_subject, bob, city_relation_object, seattle, "http://www/test.org/assertions/6", system, 1.0) bob_lives_in_seattle_hypothesis = aifutils.make_hypothesis( g, "http://www.test.edu/hypotheses/1", [bob_lives_in_seattle], system) bob_works_for_amazon = aifutils.make_relation_in_event_form( g, "http://www.test.edu/relations/2", SEEDLING_TYPES_NIST[ 'OrganizationAffiliation.EmploymentMembership'], employee_relation_subject, bob, employee_relation_object, amazon, "http://www/test.org/assertions/7", system, 1.0) aifutils.mark_depends_on_hypothesis(g, bob_works_for_amazon, bob_lives_in_seattle_hypothesis) # under the background hypothesis that Bob lives in California, we believe he works for Google bob_lives_in_california = aifutils.make_relation_in_event_form( g, "http://www.test.edu/relations/3", SEEDLING_TYPES_NIST['Physical.Resident'], city_relation_subject, bob, city_relation_object, california, "http://www/test.org/assertions/8", system, 1.0) bob_lives_in_california_hypothesis = aifutils.make_hypothesis( g, "http://www.test.edu/hypotheses/2", [bob_lives_in_california], system) bob_works_for_google = aifutils.make_relation_in_event_form( g, "http://www.test.edu/relations/4", SEEDLING_TYPES_NIST[ 'OrganizationAffiliation.EmploymentMembership'], employee_relation_subject, bob, employee_relation_object, google, "http://www/test.org/assertions/9", system, 1.0) aifutils.mark_depends_on_hypothesis( g, bob_works_for_google, bob_lives_in_california_hypothesis) self.new_file(g, "test_two_hypotheses.ttl") self.dump_graph(g, "Example of two hypotheses")
def test_create_an_entity_with_all_justification_types_and_confidence( self): g = aifutils.make_graph() g.bind('ldcOnt', SEEDLING_TYPES_NIST.uri) # every AIF needs an object for the system responsible for creating it system = aifutils.make_system_with_uri( g, "http://www.test.edu/testSystem") # it doesn't matter what URI we give entities, events, etc. so long as they are # unique entity = aifutils.make_entity(g, "http://www.test.edu/entities/1", system) # in order to allow uncertainty about the type of an entity, we don't mark an # entity's type directly on the entity, but rather make a separate assertion for it # its URI doesn't matter either type_assertion = aifutils.mark_type( g, "http://www.test.org/assertions/1", entity, SEEDLING_TYPES_NIST.Person, system, 1.0) # the justification provides the evidence for our claim about the entity's type # we attach this justification to both the type assertion and the entity object # itself, since it provides evidence both for the entity's existence and its type. # in TA1 -> TA2 communications, we attach confidences at the level of justifications aifutils.mark_text_justification(g, [entity, type_assertion], "NYT_ENG_20181231", 42, 143, system, 0.973) # let's suppose we also have evidence from an image bb1 = Bounding_Box((123, 45), (167, 98)) aifutils.mark_image_justification(g, [entity, type_assertion], "NYT_ENG_20181231_03", bb1, system, 0.123) # and also a video where the entity appears in a keyframe bb2 = Bounding_Box((123, 45), (167, 98)) aifutils.mark_keyframe_video_justification(g, [entity, type_assertion], "NYT_ENG_20181231_03", "keyframe ID", bb2, system, 0.234) # and also a video where the entity does not appear in a keyframe aifutils.mark_shot_video_justification(g, [entity, type_assertion], "SOME_VIDEO", "some shot ID", system, 0.487) # and even audio! aifutils.mark_audio_justification(g, [entity, type_assertion], "NYT_ENG_201181231", 4.566, 9.876, system, 0.789) # also we can link this entity to something in an external KB aifutils.link_to_external_kb(g, entity, "freebase.FOO", system, .398) # let's mark our entity with some arbitrary system-private data. You can attach such data # to nearly anything aifutils.mark_private_data(g, entity, "{ 'hello' : 'world' }", system) self.new_file( g, "test_create_an_entity_with_all_justification_types_and_confidence.ttl" ) self.dump_graph(g, "Example of entity with all justifications")
def test_use_subgraph_confidences_to_show_mutually_exclusive_linked_event_argument_options( self): g = aifutils.make_graph() g.bind('ldcOnt', SEEDLING_TYPES_NIST.uri) # every AIF needs an object for the system responsible for creating it system = aifutils.make_system_with_uri( g, "http://www.test.edu/testSystem") # we make a resource for the event itself event = aifutils.make_event(g, "http://www.test.edu/events/1", system) # mark the event as a Personnel.Elect event; type is encoded separately so we can express uncertainty about type aifutils.mark_type(g, "http://www.test.edu/assertions/5", event, SEEDLING_TYPES_NIST['Conflict.Attack'], system, 1.0) # create the two entities involved in the event bob = aifutils.make_entity(g, "http://www.test.edu/entities/1", system) aifutils.mark_type(g, "http://www.test.edu/assertions/6", bob, SEEDLING_TYPES_NIST.Person, system, 1.0) fred = aifutils.make_entity(g, "http://www.test.edu/entities/2", system) aifutils.mark_type(g, "http://www.test.edu/assertions/7", fred, SEEDLING_TYPES_NIST.Person, system, 1.0) # we link all possible argument fillers to the event bob_hit_fred_assertions = [ aifutils.mark_as_argument( g, event, URIRef(SEEDLING_TYPES_NIST['Conflict.Attack'] + "_Attacker"), bob, system, None), aifutils.mark_as_argument( g, event, URIRef(SEEDLING_TYPES_NIST['Conflict.Attack'] + "_Target"), fred, system, None) ] fred_hit_bob_assertions = [ aifutils.mark_as_argument( g, event, URIRef(SEEDLING_TYPES_NIST['Conflict.Attack'] + "_Attacker"), fred, system, None), aifutils.mark_as_argument( g, event, URIRef(SEEDLING_TYPES_NIST['Conflict.Attack'] + "_Target"), bob, system, None) ] # then we mark these as mutually exclusive # we also mark confidence 0.2 that neither of these are true aifutils.mark_as_mutually_exclusive( g, { tuple(bob_hit_fred_assertions): 0.6, tuple(fred_hit_bob_assertions): 0.2 }, system, 0.2) self.new_file( g, "test_use_subgraph_confidences_to_show_mutually_exclusive_linked_event_argument_options.ttl" ) self.dump_graph( g, "Example of subgraph confidences to show mutually exclusive linked event argument options" )
def test_create_hierarchical_cluster(self): # we want to say that the cluster of Trump entities might be the same as the cluster of the president entities g = aifutils.make_graph() g.bind('ldcOnt', SEEDLING_TYPES_NIST.uri) #every AIF needs an object for the system responsible for creating it system = aifutils.make_system_with_uri( g, 'http://www.test.edu/testSystem') # create president entities president_usa = aifutils.make_entity(g, "http://www.test.edu/entities/1", system) aifutils.mark_type(g, "http://www.test.edu/assertions/1", president_usa, SEEDLING_TYPES_NIST.GeopoliticalEntity, system, 1.0) aifutils.mark_name(g, president_usa, "the president") new_president = aifutils.make_entity(g, "http://www.test.edu/entities/2", system) aifutils.mark_type(g, "http://www.test.edu/assertions/2", president_usa, SEEDLING_TYPES_NIST.GeopoliticalEntity, system, 1.0) aifutils.mark_name(g, president_usa, "the newly-inaugurated president") president_45 = aifutils.make_entity(g, "http://www.test.edu/entities/3", system) aifutils.mark_type(g, "http://www.test.edu/assertions/3", president_usa, SEEDLING_TYPES_NIST.GeopoliticalEntity, system, 1.0) aifutils.mark_name(g, president_usa, "the 45th president") # cluster president entities president_cluster = aifutils.make_cluster_with_prototype( g, "http://www.test.edu/clusters/president", president_usa, system) aifutils.mark_as_possible_cluster_member(g, president_usa, president_cluster, 1, system) aifutils.mark_as_possible_cluster_member(g, new_president, president_cluster, .9, system) aifutils.mark_as_possible_cluster_member(g, president_45, president_cluster, .9, system) # create Trump entities donald_trump = aifutils.make_entity(g, "http://www.test.edu/entities/4", system) aifutils.mark_type(g, "http://www.test.edu/assertions/4", president_usa, SEEDLING_TYPES_NIST.Person, system, 1.0) aifutils.mark_name(g, president_usa, "Donald Trump") trump = aifutils.make_entity(g, "http://www.test.edu/entities/5", system) aifutils.mark_type(g, "http://www.test.edu/assertions/5", president_usa, SEEDLING_TYPES_NIST.Person, system, 1.0) aifutils.mark_name(g, president_usa, "Trump") # cluster trump entities trump_cluster = aifutils.make_cluster_with_prototype( g, "http://www.test.edu/clusters/trump", donald_trump, system) aifutils.mark_as_possible_cluster_member(g, donald_trump, trump_cluster, 1, system) aifutils.mark_as_possible_cluster_member(g, trump, trump_cluster, .9, system) aifutils.mark_as_possible_cluster_member(g, president_cluster, trump_cluster, .6, system) self.new_file(g, "test_create_hierarchical_cluster.ttl") self.dump_graph(g, "Seedling hierarchical cluster")
id_set_jpg = set([item for item in det_results_jpg]) id_set_vid = set() for imgid in det_results_vid: vidid = imgid.split('_')[0] id_set_vid.add(vidid) # In[18]: kb_dict = {} entity_dict = {} event_dict = {} for root_doc in root_to_leaf: g = aifutils.make_graph() system_pa = aifutils.make_system_with_uri( g, "http://www.columbia.edu/AIDA/USC/Systems/ObjectDetection/FasterRCNN/PascalVOC" ) system_co = aifutils.make_system_with_uri( g, "http://www.columbia.edu/AIDA/DVMM/Systems/ObjectDetection/FasterRCNN-NASNet/COCO" ) system_oi = aifutils.make_system_with_uri( g, "http://www.columbia.edu/AIDA/DVMM/Systems/ObjectDetection/FasterRCNN-InceptionResNet/OpenImages" ) system_ws = aifutils.make_system_with_uri( g,
def test_simple_hypothesis_with_importance_with_cluster(self): g = aifutils.make_graph() g.bind('ldcOnt', SEEDLING_TYPES_NIST.uri) # every AIF needs an object for the system responsible for creating it system = aifutils.make_system_with_uri( g, 'http://www.test.edu/testSystem') # buk document entity buk = aifutils.make_entity(g, "E779954.00005", system) buk_is_weapon = aifutils.mark_type( g, "https://tac.nist.gov/tracks/SM-KBP/2019/LdcAnnotations#assertion-1", buk, SEEDLING_TYPES_NIST.Weapon, system, 1.0) # buk cross-document-entity buk_kb_entity = aifutils.make_entity( g, "https://tac.nist.gov/tracks/SM-KBP/2019/LdcAnnotations#E0084", system) buk_kb_is_weapon = aifutils.mark_type( g, "https://tac.nist.gov/tracks/SM-KBP/2019/LdcAnnotations#assertion-2", buk_kb_entity, SEEDLING_TYPES_NIST.Weapon, system, 1.0) # russia document entity russia = aifutils.make_entity( g, "https://tac.nist.gov/tracks/SM-KBP/2019/LdcAnnotations#E779954.00004", system) russia_is_gpe = aifutils.mark_type( g, "https://tac.nist.gov/tracks/SM-KBP/2019/LdcAnnotations#assertion-3", russia, SEEDLING_TYPES_NIST.GeopoliticalEntity, system, 1.0) # cluster buk buk_cluster = aifutils.make_cluster_with_prototype( g, "https://tac.nist.gov/tracks/SM-KBP/2019/LdcAnnotations#cluster-1", buk_kb_entity, system) buk_is_clustered = aifutils.mark_as_possible_cluster_member( g, buk, buk_cluster, .9, system) # add importance to the cluster - test negative importance aifutils.mark_importance(g, buk_cluster, -70.234) # Russia owns buk relation buk_is_russian = aifutils.make_relation( g, "https://tac.nist.gov/tracks/SM-KBP/2019/LdcAnnotations#R779959.00004", system) aifutils.mark_type( g, "https://tac.nist.gov/tracks/SM-KBP/2019/LdcAnnotations#assertion-4", buk_is_russian, SEEDLING_TYPES_NIST['GeneralAffiliation.APORA'], system, 1.0) buk_argument = aifutils.mark_as_argument( g, buk_is_russian, SEEDLING_TYPES_NIST['GeneralAffiliation.APORA_Affiliate'], buk, system, 1.0) russia_argument = aifutils.mark_as_argument( g, buk_is_russian, SEEDLING_TYPES_NIST['GeneralAffiliation.APORA_Affiliation'], russia, system, 1.0) # add importance to the statements aifutils.mark_importance(g, buk_argument, 100.0) # add large importance aifutils.mark_importance(g, russia_argument, 9.999999e6) # Russia owns buk hypothesis buk_is_russian_hypothesis = aifutils.make_hypothesis( g, "https://tac.nist.gov/tracks/SM-KBP/2019/LdcAnnotations#hypothesis-1", [ buk, buk_is_weapon, buk_is_clustered, buk_is_russian, buk_argument, russia_argument ], system) # test highest possible importance value aifutils.mark_importance(g, buk_is_russian_hypothesis, sys.float_info.max) self.new_file(g, "test_simple_hypothesis_with_importance_cluster.ttl") self.dump_graph(g, "Simple hypothesis with importance with cluster")
def get_initialized_graph_and_system(): graph = aifutils.make_graph() graph.bind('test', prefix) system = aifutils.make_system_with_uri(graph, "http://www.test.edu/testSystem") return graph, system
class ScalingTest(): filename = "scalingdata.ttl" LDC_NS = "https://github.com/NextCenturyCorporation/AIDA-Interchange-Format/LdcAnnotations#" g = aifutils.make_graph() system = aifutils.make_system_with_uri(g, 'http://www.test.edu/testSystem') # beginning sizes of data entity_count = 128000 event_count = 38400 relations_count = 200 assertion_count = 1500 entity_index = 1 event_index = 1 relation_index = 1 assertion_index = 1 # utility values, so taht we can easily create random things abc = "ABCDEFGHIJKLMNOPQRSTUVWXYZ" entity_resource_list = [] def run_scaling_test(self): for ii in range(200): print("trying : Entity count: ", self.entity_count) start_time = int(round(time.time() * 1000)) self.run_single_test() end_time = int(round(time.time() * 1000)) duration = (start_time - end_time) / 1000 size = 0 f = open(self.filename) if os.path.isfile(self.filename): size = os.path.getsize(self.filename) size /= 1000000. print("Size of output: ", size, " duration: ", duration) # double size of entities and events after every iteration self.increase() def run_single_test(self): # adds entities and events and wrties to file for ii in range(self.entity_count): self.add_entity() for i in range(self.event_count): self.add_event() self.write_to_file(self.filename) def add_entity(self): # add an entity entity_resource = aifutils.make_entity(self.g, self.get_entity_uri(), self.system) self.entity_resource_list.append(entity_resource) # sometimes add hasName, textValue, or numericValue, NOTE: This does not check type!!! rand = random.random() if rand < 0.15: aifutils.mark_name(self.g, entity_resource, self.get_random_string(5)) elif rand < 0.3: aifutils.mark_text_value(self.g, entity_resource, self.get_random_string(7)) elif rand < 0.4: aifutils.mark_numeric_value_as_double(self.g, entity_resource, random.random()) # set the type type_to_use = self.get_random_entity() type_assertion = aifutils.mark_type(self.g, self.get_assertion_uri(), entity_resource, type_to_use, self.system, 1.0) self.add_justification_and_private_data(type_assertion) def add_event(self): # add an event event_resource = aifutils.make_event(self.g, self.get_event_uri(), self.system) # add the type type_resource = self.EVENT_TYPES[ random.randint(0, len(self.EVENT_TYPES)) - 1] type_assertion = aifutils.mark_type(self.g, self.get_assertion_uri(), event_resource, type_resource, self.system, 1.0) self.add_justification_and_private_data(type_assertion) # make two arguments for i in range(2): arg = URIRef(type_resource + self.get_random_suffix()) argument = aifutils.mark_as_argument(self.g, event_resource, arg, self.get_random_entity(), self.system, 0.785, self.get_assertion_uri()) self.add_justification_and_private_data(argument) def add_justification_and_private_data(self, resource): docId = self.get_random_doc_id() # justify the type assertion aifutils.mark_text_justification(self.g, resource, docId, 1029, 1033, self.system, 0.973) # add some private data aifutils.mark_private_data(self.g, resource, "{ 'provenance' : '" + docId + "' }", self.system) def increase(self): self.entity_count *= 2 self.event_count *= 2 def get_uri(self, uri): return self.LDC_NS + uri def get_entity_uri(self): self.entity_index += 1 return self.get_uri("entity-" + str(self.entity_index)) def get_event_uri(self): self.event_index += 1 return self.get_uri("event-" + str(self.event_index)) def get_relation_uri(self): self.relation_index += 1 return self.get_uri("relation-" + str(self.relation_index)) def get_assertion_uri(self): self.assertion_index += 1 return self.get_uri("assertion-" + str(self.assertion_index)) def get_test_system_uri(self): return self.get_uri("testSystem") def get_random_doc_id(self): s = "" if random.getrandbits(1) == 1: s += "IC" else: s += "HC" s += "00" s += "" + str((random.randint(0, 1000))) s += self.abc[random.randint(0, len(self.abc) - 1)] s += self.abc[random.randint(0, len(self.abc) - 1)] s += self.abc[random.randint(0, len(self.abc) - 1)] return s def get_random_string(self, length): s = "" for i in range(0, length): s += self.abc[random.randint(0, len(self.abc) - 1)] return s def get_random_entity(self): return self.ENTITY_TYPES[random.randint(0, len(self.ENTITY_TYPES) - 1)] def get_random_suffix(self): s = "_" + self.ROLES[random.randint(0, len(self.ROLES) - 1)] return s def write_to_file(self, testname): print("\n\n", testname, "\n\n") file = open(testname, "w") file.write(str(self.g.serialize(format='turtle'))) file.close() ENTITY_TYPES = [ seedling_ontology.Person, seedling_ontology.Organization, seedling_ontology.Location, seedling_ontology.Facility, seedling_ontology.GeopoliticalEntity, seedling_ontology.FillerType, seedling_ontology.Business_DeclareBankruptcy, seedling_ontology.Business_End, seedling_ontology.Business_Merge, seedling_ontology.Business_Start, seedling_ontology.Conflict_Attack, seedling_ontology.Conflict_Demonstrate, seedling_ontology.Contact_Broadcast, seedling_ontology.Contact_Contact, seedling_ontology.Contact_Correspondence, seedling_ontology.Contact_Meet, seedling_ontology.Existence_DamageDestroy, seedling_ontology.Government_Agreements, seedling_ontology.Government_Legislate, seedling_ontology.Government_Spy, seedling_ontology.Government_Vote, seedling_ontology.Inspection_Artifact, seedling_ontology.Inspection_People, seedling_ontology.Justice_Acquit, seedling_ontology.Justice_Appeal, seedling_ontology.Justice_ArrestJail, seedling_ontology.Justice_ChargeIndict, seedling_ontology.Justice_Convict, seedling_ontology.Justice_Execute, seedling_ontology.Justice_Extradite, seedling_ontology.Justice_Fine, seedling_ontology.Justice_Investigate, seedling_ontology.Justice_Pardon, seedling_ontology.Justice_ReleaseParole, seedling_ontology.Justice_Sentence, seedling_ontology.Justice_Sue, seedling_ontology.Justice_TrialHearing, seedling_ontology.Life_BeBorn, seedling_ontology.Life_Die, seedling_ontology.Life_Divorce, seedling_ontology.Life_Injure, seedling_ontology.Life_Marry, seedling_ontology.Manufacture_Artifact, seedling_ontology.Movement_TransportArtifact, seedling_ontology.Movement_TransportPerson, seedling_ontology.Personnel_Elect, seedling_ontology.Personnel_EndPosition, seedling_ontology.Personnel_Nominate, seedling_ontology.Personnel_StartPosition, seedling_ontology.Transaction_Transaction, seedling_ontology.Transaction_TransferControl, seedling_ontology.Transaction_TransferMoney, seedling_ontology.Transaction_TransferOwnership, seedling_ontology.GeneralAffiliation_APORA, seedling_ontology.GeneralAffiliation_MORE, seedling_ontology.GeneralAffiliation_OPRA, seedling_ontology.GeneralAffiliation_OrganizationWebsite, seedling_ontology.GeneralAffiliation_PersonAge, seedling_ontology.GeneralAffiliation_Sponsorship, seedling_ontology.Measurement_Count, seedling_ontology.OrganizationAffiliation_EmploymentMembership, seedling_ontology.OrganizationAffiliation_Founder, seedling_ontology.OrganizationAffiliation_InvestorShareholder, seedling_ontology.OrganizationAffiliation_Leadership, seedling_ontology.OrganizationAffiliation_Ownership, seedling_ontology.OrganizationAffiliation_StudentAlum, seedling_ontology.PartWhole_Membership, seedling_ontology.PartWhole_Subsidiary, seedling_ontology.PersonalSocial_Business, seedling_ontology.PersonalSocial_Family, seedling_ontology.PersonalSocial_RoleTitle, seedling_ontology.PersonalSocial_Unspecified, seedling_ontology.Physical_LocatedNear, seedling_ontology.Physical_OrganizationHeadquarter, seedling_ontology.Physical_OrganizationLocationOrigin, seedling_ontology.Physical_Resident ] EVENT_TYPES = [ seedling_ontology.Business_DeclareBankruptcy, seedling_ontology.Business_End, seedling_ontology.Business_Merge, seedling_ontology.Business_Start, seedling_ontology.Conflict_Attack, seedling_ontology.Conflict_Demonstrate, seedling_ontology.Contact_Broadcast, seedling_ontology.Contact_Contact, seedling_ontology.Contact_Correspondence, seedling_ontology.Contact_Meet, seedling_ontology.Existence_DamageDestroy, seedling_ontology.Government_Agreements, seedling_ontology.Government_Legislate, seedling_ontology.Government_Spy, seedling_ontology.Government_Vote, seedling_ontology.Inspection_Artifact, seedling_ontology.Inspection_People, seedling_ontology.Justice_Acquit, seedling_ontology.Justice_Appeal, seedling_ontology.Justice_ArrestJail, seedling_ontology.Justice_ChargeIndict, seedling_ontology.Justice_Convict, seedling_ontology.Justice_Execute, seedling_ontology.Justice_Extradite, seedling_ontology.Justice_Fine, seedling_ontology.Justice_Investigate, seedling_ontology.Justice_Pardon, seedling_ontology.Justice_ReleaseParole, seedling_ontology.Justice_Sentence, seedling_ontology.Justice_Sue, seedling_ontology.Justice_TrialHearing, seedling_ontology.Life_BeBorn, seedling_ontology.Life_Die, seedling_ontology.Life_Divorce, seedling_ontology.Life_Injure, seedling_ontology.Life_Marry, seedling_ontology.Manufacture_Artifact, seedling_ontology.Movement_TransportArtifact, seedling_ontology.Movement_TransportPerson, seedling_ontology.Personnel_Elect, seedling_ontology.Personnel_EndPosition, seedling_ontology.Personnel_Nominate, seedling_ontology.Personnel_StartPosition, seedling_ontology.Transaction_Transaction, seedling_ontology.Transaction_TransferControl, seedling_ontology.Transaction_TransferMoney, seedling_ontology.Transaction_TransferOwnership ] ROLES = [ "Attacker", "Instrument", "Place", "Target", "Time", "Broadcaster", "Place", "Time", "Participant", "Place", "Participant", "Time", "Participant", "Affiliate", "Affiliation", "Affiliation", "Person", "Entity", "Sponsor", "Defendant", "Prosecutor", "Adjudicator", "Defendant", "Agent", "Instrument", "Victim", "Artifact", "Manufacturer", "Agent", "Artifact", "Destination", "Instrument", "Origin", "Time", "Agent", "Destination", "Instrument", "Origin", "Person", "Employee", "Organization", "Person", "Entity", "Place", "Beneficiary", "Giver", "Recipient", "Thing", "Time" ]
def test_create_compound_justification(self): g = aifutils.make_graph() system = aifutils.make_system_with_uri(g, "http://www.test.edu/system") event = aifutils.make_event( g, "https://tac.nist.gov/tracks/SM-KBP/2019/LdcAnnotations#V779961.00010", system) event_type_assertion = aifutils.mark_type( g, "https://tac.nist.gov/tracks/SM-KBP/2019/LdcAnnotations#assertion-1", event, SEEDLING_TYPES_NIST['Personnel.Elect'], system, 1.0) # create the two entities involved in the event putin = aifutils.make_entity( g, "https://tac.nist.gov/tracks/SM-KBP/2019/LdcAnnotations#E781167.00398", system) person_type_assertion = aifutils.mark_type( g, "https://tac.nist.gov/tracks/SM-KBP/2019/LdcAnnotations#assertion-2", putin, SEEDLING_TYPES_NIST.Person, system, 1.0) russia = aifutils.make_entity( g, "https://tac.nist.gov/tracks/SM-KBP/2019/LdcAnnotations#E779954.00004", system) gpe_type_assertion = aifutils.mark_type( g, "https://tac.nist.gov/tracks/SM-KBP/2019/LdcAnnotations#assertion-3", russia, SEEDLING_TYPES_NIST.GeopoliticalEntity, system, 1.0) # link those entities to the event electee_argument = aifutils.mark_as_argument( g, event, SEEDLING_TYPES_NIST['Personnel.Elect_Elect'], putin, system, 0.785, "https://tac.nist.gov/tracks/SM-KBP/2019/LdcAnnotations#assertion-4" ) place_argument = aifutils.mark_as_argument( g, event, SEEDLING_TYPES_NIST['Personnel.Elect_Place'], russia, system, 0.589, "https://tac.nist.gov/tracks/SM-KBP/2019/LdcAnnotations#assertion-5" ) # the justification provides the evidence for our claim about the entity's type # we attach this justification to both the type assertion and the entity object itself, since it provides # evidence both for the entity's existence and its type. # in TA1 -> TA2 communications, we attach confidences at the level of justifications text_justification = aifutils.make_text_justification( g, "NYT_ENG_20181231", 42, 143, system, 0.973) aifutils.mark_justification(g, person_type_assertion, text_justification) aifutils.mark_justification(g, putin, text_justification) aifutils.add_source_document_to_justification( g, text_justification, "NYT_PARENT_ENG_20181231_03") bb1 = Bounding_Box((123, 45), (167, 98)) # let's suppose we also have evidence from an image image_justification = aifutils.make_image_justification( g, "NYT_ENG_20181231_03", bb1, system, 0.123) bb2 = Bounding_Box((234, 56), (345, 101)) # and also a video where the entity appears in a keyframe keyframe_video_justification = aifutils.make_keyframe_video_justification( g, "NYT_ENG_20181231_03", "keyframe ID", bb2, system, .0234) #and also a video where the entity does not appear in a keyframe shot_video_justification = aifutils.make_shot_video_justification( g, "SOME_VIDEO", "some shot ID", system, 0.487) # and even audio! audio_justification = aifutils.make_audio_justification( g, "NYT_ENG_201181231", 4.566, 9.876, system, 0.789) # combine all justifications into single justifiedBy triple with new confidence aifutils.mark_compound_justification(g, [electee_argument], [ text_justification, image_justification, keyframe_video_justification, shot_video_justification, audio_justification ], system, .321) aifutils.mark_compound_justification( g, [place_argument], [text_justification, image_justification], system, 0.543) self.new_file(g, "test_create_compound_justification.ttl") self.dump_graph(g, "Example of compound justification")