def test_create_event(self): g, system = get_initialized_graph_and_system() # make event with type election election = aifutils.make_event(g, prefix + "event/1", system) aifutils.mark_type(g, prefix + "types/1", election, "Q40231", system, 1.0) # make entity with type person putin = aifutils.make_entity(g, prefix + "entity/putin", system) aifutils.mark_type(g, prefix + "types/2", putin, "Q5", system, 1.0) # make entity with type political region russia = aifutils.make_entity(g, prefix + "enitty/russia", system) aifutils.mark_type(g, prefix + "types/3", russia, "Q1048835", system, 1.0) # add putin as cadidate for the election aifutils.mark_as_argument(g, election, "A1_ppt_theme_candidate", putin, system, .785, prefix + "arg/candidate") # add russia as location for election aifutils.mark_as_argument(g, election, "AM_loc__location", russia, system, .589, prefix + "arg/location") self.new_file(g, "test_create_event.ttl") self.dump_graph(g, "Example of event and entity")
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_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_entity_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_entity(g, "http://www.test.edu/entities/1", system) self.dump_graph(g, "Invalid: Entity missing type")
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_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_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_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_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_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_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_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_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_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_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 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 create_base_claim(self): g, system = get_initialized_graph_and_system() claimObject = Claim() validComponentKE = aifutils.make_entity( g, prefix + "entities/validComponentKE", system) validProtoType = aifutils.make_entity(g, prefix + "entities/validID1", system) validSameAsCluster1 = aifutils.make_cluster_with_prototype( g, prefix + "cluster/clusterA/SameAsCluster/ClusterID1", validProtoType, system) validSameAsCluster2 = aifutils.make_cluster_with_prototype( g, prefix + "cluster/clusterB/SameAsCluster/ClusterID2", validProtoType, system) validSameAsCluster3 = aifutils.make_cluster_with_prototype( g, prefix + "cluster/clusterC/SameAsCluster/ClusterID3", validProtoType, system) validClaimComponent = ClaimComponent() validClaimComponent.setName = "Some Agency" validClaimComponent.setIdentity = "Q37230" validClaimComponent.addType = "Q47913" validClaimComponent.setProvenance = "Some Text from Document as Provenance" validClaimComponent.setKe = validComponentKE validXClaimComponent = aifutils.make_claim_component( g, prefix + "SomeAgency", validClaimComponent, system) validClaimComponent = ClaimComponent() validClaimComponent.setName = "Some Agency2" validClaimComponent.setIdentity = "Q8333" validClaimComponent.addType = "Q47913" validClaimComponent.addType = "Q6" validClaimComponent.setProvenance = "Some Text from Document as Provenance" validClaimComponent.setKe = validComponentKE validX2ClaimComponent = aifutils.make_claim_component( g, prefix + "SomeAgency2", validClaimComponent, system) validClaimComponent = ClaimComponent() validClaimComponent.setName = "Some News Anchor" validClaimComponent.setIdentity = "Q2096683" validClaimComponent.addType = "Q1930187" validClaimComponent.addType = "Q5" validClaimComponent.setProvenance = "Some Text from Document as Provenance" validClaimComponent.setKe = validComponentKE validClaimerClaimComponent = aifutils.make_claim_component( g, prefix + "SomeNewsAnchor", validClaimComponent, system) claimObject.addAssociatedKE = validSameAsCluster1 claimObject.addAssociatedKE = validSameAsCluster2 claimObject.claimer = validClaimerClaimComponent claimObject.addClaimSemantics = validSameAsCluster2 claimObject.addClaimSemantics = validSameAsCluster3 claimObject.claimTemplate = "X killed Hugo Chavez" claimObject.naturalLanguageDescription = "Claimer Y claims X killed Hugo Chavez" claimObject.subtopic = "Some Sub TubTopic: Who killed Hugo Chavez" claimObject.sourceDocument = "Some source Doc" claimObject.topic = "Some Main Topic: Hugo Chavez" claimObject.addXVariable = validXClaimComponent claimObject.addXVariable = validX2ClaimComponent return g, system, claimObject
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")
def transferAIF(parent): chi = child[parent] if parent in kb_dict.keys(): g = kb_dict[parent] else: g = aifutils.make_graph() entityDic_c = {} country_set_r = set() for img_id in chi: if img_id in flag_dict_s.keys(): country_set_r.add(flag_dict_s[img_id]) #=============== Flag =========== sys = aifutils.make_system_with_uri( g, "http://www.columbia.edu/AIDA/DVMM/Systems/Flag/Inception_v4") for key, value in index_category_f.items(): if key not in country_set_r: continue key = key.replace(' ', '_') name = "http://www.columbia.edu/AIDA/DVMM/Entities/Country/" + str( value) + '/' + key entity = aifutils.make_entity(g, name, sys) entityDic_c[key] = entity #print "parent "+ parent type_assertion = aifutils.mark_type(g, \ "http://www.columbia.edu/AIDA/DVMM/TypeAssertion/Country/"\ +str(value)+'/'+key, entity, AIDA_PROGRAM_ONTOLOGY_G.term('GPE'), sys, 1) for img_id in chi: if img_id in flag_dict_s.keys(): #print "imgID "+img_id flag_label = [ '/m/07cmd', '/m/0dzct', '/m/03bt1vf', '/m/01g317', '/m/04yx4', '/m/01prls', '/m/07yv9', '/m/03120' ] key = img_id if key in OD_result.keys(): for n in range(len(OD_result[key])): eid = "http://www.columbia.edu/AIDA/DVMM/Entities/ObjectDetection/RUN00010/JPG/" + key + "/" + str( n) #print OD_result[key][n]['label'] if OD_result[key][n]['label'] in flag_label: #print OD_result[key][n]['label'] eid = "http://www.columbia.edu/AIDA/DVMM/Entities/ObjectDetection/RUN00010/JPG/" + key + "/" + str( n) relation_entity = aifutils.make_relation(g, "http://www.columbia.edu/AIDA/DVMM/Relaion/Flag/"+\ key+"/"+str(n), sys) #APORA = 'GeneralAffiliation.ArtifactPoliticalOrganizationReligiousAffiliation' score = 1 type_assertion = aifutils.mark_type(g, "http://www.columbia.edu/AIDA/DVMM/TypeAssertion/Flag/"+key+"/"+str(n), \ relation_entity, AIDA_PROGRAM_ONTOLOGY_A['GeneralAffiliation.ArtifactPoliticalOrganizationReligiousAffiliation.NationalityCitizen'], \ sys, score) boxA = OD_result[key][n]['bbox'] bb2 = Bounding_Box((boxA[0], boxA[1]), (boxA[2], boxA[3])) score = 1 justif = aifutils.mark_image_justification(g, [relation_entity, \ type_assertion], key, bb2, sys, score) aifutils.add_source_document_to_justification( g, justif, parent) aifutils.mark_informative_justification( g, relation_entity, justif) score = 1 if eid in entity_dict.keys(): art_argument = aifutils.mark_as_argument(g, relation_entity, \ AIDA_PROGRAM_ONTOLOGY_A['GeneralAffiliation.ArtifactPoliticalOrganizationReligiousAffiliation.NationalityCitizen_Artifact'], \ entity_dict[eid], sys, score) score = 1 justif = aifutils.mark_image_justification(g, [relation_entity, \ art_argument], key, bb2, sys, score) aifutils.add_source_document_to_justification( g, justif, parent) aifutils.mark_informative_justification( g, relation_entity, justif) score = 1 nation_argument = aifutils.mark_as_argument(g, relation_entity, \ AIDA_PROGRAM_ONTOLOGY_A['GeneralAffiliation.ArtifactPoliticalOrganizationReligiousAffiliation.NationalityCitizen_Nationality'], \ entityDic_c[flag_dict_s[img_id]], \ sys, score) score = 1 justif = aifutils.mark_image_justification(g, [relation_entity, \ nation_argument], key, bb2, sys, score) aifutils.add_source_document_to_justification( g, justif, parent) aifutils.mark_informative_justification( g, relation_entity, justif) if OD_result[key][n]['label'] == '/m/03120': #print flag_dict_s[img_id] boxA = OD_result[key][n]['bbox'] bb2 = Bounding_Box((boxA[0], boxA[1]), (boxA[2], boxA[3])) type_assertion = aifutils.mark_type(g, \ "http://www.columbia.edu/AIDA/DVMM/TypeAssertion/Country/RUN00010/JPG/"+\ str(key)+'/'+str(n), entityDic_c[flag_dict_s[img_id]], AIDA_PROGRAM_ONTOLOGY_G.term('GPE'), sys, 1) score = 1 justif = aifutils.mark_image_justification(g, [entityDic_c[flag_dict_s[img_id]], type_assertion], \ key, bb2, sys, score) aifutils.add_source_document_to_justification( g, justif, parent) aifutils.mark_informative_justification( g, entityDic_c[flag_dict_s[img_id]], justif) #break #=============== landmark ========== sys = aifutils.make_system_with_uri( g, "http://www.columbia.edu/AIDA/DVMM/Systems/Landmark/Delf") #building has_land = 0 landmark_name_set = set() for imageN in chi: if imageN in landmark_dict.keys(): name_lm = landmark_dict[imageN] if name_lm == '': continue #print name_lm if name_lm not in landmark_name_set: landmark_name_set.add(name_lm) name = "http://www.columbia.edu/AIDA/DVMM/Entities/Landmark/"+ \ str(landmark_id[name_lm])+"/"+name_lm entity = aifutils.make_entity(g, name, sys) entityDic_b[name_lm] = entity #print AIDA_PROGRAM_ONTOLOGY2.term('Person') score = 1 type_assertion = aifutils.mark_type(g, \ "http://www.columbia.edu/AIDA/DVMM/TypeAssertion/Landmark/"+ \ str(landmark_id[name_lm])+"/"+name_lm \ , entity, AIDA_PROGRAM_ONTOLOGY_b.term('FAC'), sys, score) if 'Maidan' in name_lm: aifutils.link_to_external_kb(g, entity, "LDC2019E43:80000020", sys, 1) elif 'United_States_Capitol' in name_lm: aifutils.link_to_external_kb(g, entity, "LDC2019E43:4140827", sys, 1) else: aifutils.link_to_external_kb(g, entity, VIS_ONTOLOGY_b.term(name_lm), sys, 1) for imageN in chi: total_key.add(imageN) if imageN in landmark_dict.keys(): #print parent key = imageN name_lm = landmark_dict[imageN] if name_lm == '': continue #aifutils.mark_as_possible_cluster_member(g, \ # entity,clusterDic_b[0], 1, sys) # Need to change in future im = Image.open(input_img_path + imageN + '.jpg') width, height = im.size bb2 = Bounding_Box((0, 0), (width, height)) #l u r d type_assertion = aifutils.mark_type(g, \ "http://www.columbia.edu/AIDA/DVMM/TypeAssertion/Landmark/RUN00010/JPG/"+\ str(key)+'/'+str(0), entityDic_b[name_lm], AIDA_PROGRAM_ONTOLOGY_b.term('FAC'), sys, 1) justif = aifutils.mark_image_justification( g, [entityDic_b[name_lm], type_assertion], key, bb2, sys, 1) aifutils.add_source_document_to_justification(g, justif, parent) aifutils.mark_informative_justification(g, entityDic_b[name_lm], justif) #=============face recognition============= sys = aifutils.make_system_with_uri( g, "http://www.columbia.edu/AIDA/DVMM/Systems/Face/FaceNet") NameDetected = set() NameDetected_score = {} nameCount = Counter() count = 0 c_num = 0 person_c_n = 0 #print comblineSet In = 0 #print bb featureDic = {} first = 1 entityList = [] arrayList = [] person_label = [ '/m/01g317', '/m/04yx4', '/m/03bt1vf', '/m/01bl7v', '/m/05r655', '/m/04hgtk', '/m/01bgsw' ] for x, y in result.items(): #print x data = x.split('/')[-1] if '._' in data: continue data2 = data.split('_') #print data2[0] #print data2[1][:-4] key = data2[0] i = data2[1][:-4] #print chi #print key if key not in chi: continue if y[0].replace(' ', '_') not in nameSet or nameDic[y[0].replace( ' ', '_')] not in p1Set or float(y[1]) < 0.04 or y[0].replace( ' ', '_') == 'Ban_Ki-moon': continue else: NameDetected.add(nameDic[y[0].replace(' ', '_')]) score = float(y[1]) + 0.5 NameDetected_score[nameDic[y[0].replace(' ', '_')]] = min(1, score) for x, y in result2.items(): #print x data = x.split('/')[-2] if '._' in data: continue data = x.split('/')[-1] data2 = data.split('_') key = x.split('/')[-2] if videoDic[key] not in chi: continue if y[0].replace(' ', '_') not in nameSet or nameDic[y[0].replace( ' ', '_')] not in p1Set or float(y[1]) < 0.04 or y[0].replace( ' ', '_') == 'Ban_Ki-moon': continue else: NameDetected.add(nameDic[y[0].replace(' ', '_')]) score = float(y[1]) + 0.5 NameDetected_score[nameDic[y[0].replace(' ', '_')]] = min(1, score) for key, value in index_category.items(): #key name. value is number if key not in NameDetected: continue key = key.replace(' ', '_') #keu = entityDic name = "http://www.columbia.edu/AIDA/DVMM/Entities/FaceID/" + str( value) + '/' + key entity = aifutils.make_entity(g, name, sys) entityDic[key] = entity #print AIDA_PROGRAM_ONTOLOGY2.term('Person') #score = NameDetected_score[key] type_assertion = aifutils.mark_type(g, \ "http://www.columbia.edu/AIDA/DVMM/TypeAssertion/FaceID/"\ +str(value)+'/'+key, entity, AIDA_PROGRAM_ONTOLOGY2.term('PER'), sys, 1) new_key = key.lower().replace('_', ' ') if new_key in name2ID.keys(): aifutils.link_to_external_kb(g, entity, "LDC2019E43:" + name2ID[new_key], sys, 1) #print 'Lorelei' #print parent else: a = 0 #print 'dbpedia' #print parent aifutils.link_to_external_kb(g, entity, VIS_ONTOLOGY2.term(key), sys, 1) for x, y in result.items(): #print x data = x.split('/')[-1] if '._' in data: continue data2 = data.split('_') #print data2[0] #print data2[1][:-4] key = data2[0] i = data2[1][:-4] #print chi #print key if key not in chi: continue #print chi #print key In = 1 name = "http://www.columbia.edu/AIDA/DVMM/Entities/FaceDetection/RUN00010/" + str( key) + '/' + str(i) #entityList.append(key) #entityList.append(entity) entity = aifutils.make_entity(g, name, sys) first_cluster = 1 #======================== JPG =============== eid_list = [] if key in OD_result.keys(): for n in range(len(OD_result[key])): #print OD_result[key][n]['label'] if OD_result[key][n]['label'] in person_label: #print OD_result[key][n]['label'] boxA = OD_result[key][n]['bbox'] boxB = (int(bb[x][0]), int(bb[x][1]), int(bb[x][2]), int(bb[x][3])) IOA = bb_intersection_over_union(boxA, boxB) if IOA > 0.9: #left,top,right,bottom = OD_result[key][n]['bbox'] #if int(bb[x][1]) > left and int(bb[x][0]) > top and int(bb[x][3]) < right and int(bb[x][2]) < bottom: eid = "http://www.columbia.edu/AIDA/DVMM/Entities/ObjectDetection/RUN00010/JPG/" + key + "/" + str( n) #print entity_dic2[key] #print n if n in entity_dic2[key]: #if eid in entity_dict.keys(): score = IOA eid_list.append(eid) if first_cluster == 1: first_cluster = 0 clusterName = aifutils.make_cluster_with_prototype(g, \ "http://www.columbia.edu/AIDA/DVMM/Clusters/HumanBody/RUN00010/JPG/"\ +key+"/"+str(n)+"/"+str(person_c_n),entity, sys) aifutils.mark_as_possible_cluster_member(g, \ entity_dict[eid],clusterName, score, sys) if first_cluster == 0: person_c_n += 1 l, t, r, d = bb[x] if (r - l) * (d - t) > 3600: entityList.append(entity) arrayList.append(y[2]) feature = {} feature['columbia_vector_faceID_FaceNet'] = y[2].tolist() json_data = json.dumps(feature) aifutils.mark_private_data(g, entity, json_data, sys) #labelrdf = VIS_ONTOLOGY.term(i_id) #Dscore = value[i][7] #if Dscore>1: Dscore = 1 #type_assertion = aifutils.mark_type(g, "Columbia/DVMM/TypeAssertion/FaceRecognition/RUN00003/"+str(i_id)+"/"+str(i)+"/1", type_assertion = aifutils.mark_type(g, \ "http://www.columbia.edu/AIDA/DVMM/TypeAssertion/FaceDetection/RUN00010/JPG/"+\ str(key)+'/'+str(i), entity, AIDA_PROGRAM_ONTOLOGY2.term('PER'), sys, Dscore) bb2 = Bounding_Box((bb[x][0], bb[x][1]), (bb[x][2], bb[x][3])) justif = aifutils.mark_image_justification(g, [entity, type_assertion], key, bb2, sys, 1) aifutils.add_source_document_to_justification(g, justif, parent) aifutils.mark_informative_justification(g, entity, justif) chi_set.add(key) parent_set.add(parent) if y[0].replace(' ', '_') not in nameSet or nameDic[y[0].replace( ' ', '_')] not in p1Set or float(y[1]) < 0.04 or y[0].replace( ' ', '_') == 'Ban_Ki-moon': continue else: #nameCount2+=1 person_set.add(y[0]) doc_N.add(parent) img_N.add(key) score = sigmoid(float(y[1]) * 10) NameDetected.add(nameDic[y[0].replace(' ', '_')]) #print y[0] entity_key = nameDic[y[0].replace(' ', '_')] type_assertion = aifutils.mark_type(g, \ "http://www.columbia.edu/AIDA/DVMM/TypeAssertion/FaceID/"\ +str(index_category[entity_key])+'/'+entity_key, entityDic[entity_key], AIDA_PROGRAM_ONTOLOGY2.term('PER'), sys, 1) justif = aifutils.mark_image_justification(g, [entityDic[nameDic[y[0].replace(' ','_')]], \ type_assertion], key, bb2, sys, score) aifutils.add_source_document_to_justification(g, justif, parent) aifutils.mark_informative_justification( g, entityDic[nameDic[y[0].replace(' ', '_')]], justif) # entity, labelrdf, sys, score) #print str(value[i][2]).replace("L",'') #========================== Video Frame ================ for x, y in result2.items(): #print x data = x.split('/')[-2] if '._' in data: continue data = x.split('/')[-1] data2 = data.split('_') key = x.split('/')[-2] if videoDic[key] not in chi: continue #print "video" In = 1 i = data2[-1][:-4] frame = data[:-len(data2[-1]) - 1] frameNum = frame.split('_')[-1] name = "http://www.columbia.edu/AIDA/DVMM/Entities/FaceDetection/RUN00010/Keyframe/"+\ str(videoDic[key])+'_'+str(frameNum)+'/'+str(i) entity = aifutils.make_entity(g, name, sys) if str(videoDic[key]) + '_' + str(frameNum) in ODF_result.keys(): first_cluster = 1 for n in range( len(ODF_result[str(videoDic[key]) + '_' + str(frameNum)])): if ODF_result[str(videoDic[key]) + '_' + str(frameNum)][n]['label'] in person_label: boxA = ODF_result[str(videoDic[key]) + '_' + str(frameNum)][n]['bbox'] boxB = (int(bb_2[x][0]), int(bb_2[x][1]), int(bb_2[x][2]), int(bb_2[x][3])) IOA = bb_intersection_over_union(boxA, boxB) if IOA > 0.9: eid = "http://www.columbia.edu/AIDA/DVMM/Entities/ObjectDetection/RUN00010/Keyframe/" + str( videoDic[key]) + '_' + str(frameNum) + "/" + str(n) if n in entity_dic2[str(videoDic[key]) + '_' + str(frameNum)]: #if eid in entity_dict.keys(): score = IOA #print x #print entity_dict[eid] #print n if first_cluster == 1: first_cluster = 0 clusterName = aifutils.make_cluster_with_prototype(g, \ "http://www.columbia.edu/AIDA/DVMM/Clusters/HumanBody/RUN00010/Keyframe/"+\ str(videoDic[key])+'_'+str(frameNum)+'/'+str(i)+'/'+\ str(person_c_n),entity, sys) #aifutils.mark_as_possible_cluster_member(g, \ # entity,clusterName, score, sys) aifutils.mark_as_possible_cluster_member(g, \ entity_dict[eid],clusterName, score, sys) if first_cluster == 0: person_c_n += 1 #txn.put("Columbia/DVMM/TypeAssertion/FaceID/RUN00003/"+str(key)+'/'+str(i), value[i][4]); #featureDic[entity] = y[2] featureDic[key] = y[2] #entityList.append(key) l, t, r, d = bb_2[x] if (r - l) * (d - t) > 3600: entityList.append(entity) arrayList.append(y[2]) #if first == 1: # new_array = [y[2]] # first = 0 #else: # new_array = np.concatenate((new_array, [y[2]]), axis=0) feature = {} feature['columbia_vector_faceID_FaceNet'] = y[2].tolist() json_data = json.dumps(feature) aifutils.mark_private_data(g, entity, json_data, sys) #labelrdf = VIS_ONTOLOGY.term(i_id) #Dscore = value[i][7] #if Dscore>1: Dscore = 1 #type_assertion = aifutils.mark_type(g, "Columbia/DVMM/TypeAssertion/FaceRecognition/RUN00003/"+str(i_id)+"/"+str(i)+"/1", type_assertion = aifutils.mark_type(g, "http://www.columbia.edu/AIDA/DVMM/TypeAssertion/FaceDetection/RUN00010/Keyframe/"+\ str(videoDic[key])+'_'+str(frameNum)+'/'+str(i), entity, AIDA_PROGRAM_ONTOLOGY2.term('PER'), sys, Dscore) #str(videoDic[key])+'_'+str(frameNum)+'/'+str(i), entity, AIDA_PROGRAM_ONTOLOGY2.Entity, sys, Dscore) #print bb[x][1] bb2 = Bounding_Box((bb_2[x][0], bb_2[x][1]), (bb_2[x][2], bb_2[x][3])) #aifutils.mark_image_justification(g, [entity, type_assertion], key, bb2, sys, 1) justif = aifutils.mark_keyframe_video_justification(g, [entity, type_assertion], videoDic[key], \ str(videoDic[key])+'_'+str(frameNum), bb2, sys, 1) aifutils.add_source_document_to_justification(g, justif, parent) aifutils.mark_informative_justification(g, entity, justif) chi_set.add(key) parent_set.add(parent) if y[0].replace(' ', '_') not in nameSet or nameDic[y[0].replace( ' ', '_')] not in p1Set or float(y[1]) < 0.04 or y[0].replace( ' ', '_') == 'Ban_Ki-moon': continue else: #nameCount2+=1 person_set.add(y[0]) doc_N.add(parent) img_N.add(key) #if float(y[1])*10>1: # score = 1-random.random()/10 #else: # score = float(y[1])*10 score = sigmoid(float(y[1]) * 10) #place_of_birth_in_louisville_cluster = aifutils.mark_as_possible_cluster_member(g, \ # entity,clusterDic[nameDic[y[0].replace(' ','_')]], score, sys) NameDetected.add(nameDic[y[0].replace(' ', '_')]) entity_key = nameDic[y[0].replace(' ', '_')] type_assertion = aifutils.mark_type(g, \ "http://www.columbia.edu/AIDA/DVMM/TypeAssertion/FaceID/"\ +str(index_category[entity_key])+'/'+entity_key, entityDic[entity_key], AIDA_PROGRAM_ONTOLOGY2.term('PER'), sys, 1) justif = aifutils.mark_keyframe_video_justification(g, [entityDic[nameDic[y[0].replace(' ','_')]], type_assertion], videoDic[key], \ str(videoDic[key])+'_'+str(frameNum), bb2, sys, score) aifutils.add_source_document_to_justification(g, justif, parent) aifutils.mark_informative_justification( g, entityDic[nameDic[y[0].replace(' ', '_')]], justif) #dbscan_run(arrayList,entityList) new_array = np.array(arrayList) if len(arrayList) > 1: # Compute DBSCAN #if __name__ == '__main__': db = DBSCAN(eps=0.55, min_samples=2).fit(new_array) core_samples_mask = np.zeros_like(db.labels_, dtype=bool) core_samples_mask[db.core_sample_indices_] = True labels = db.labels_ #print labels # Number of clusters in labels, ignoring noise if present. n_clusters_ = len(set(labels)) - (1 if -1 in labels else 0) #print entityList #print('Estimated number of clusters: %d' % n_clusters_) clusterNameDic = {} firstMem = [0 for i in range(n_clusters_)] firstArray = {} for i in range(len(labels)): if labels[i] == -1: continue #print len(labels) #print len(entityList) #score = 1 if firstMem[labels[i]] == 0: firstMem[labels[i]] = 1 firstArray[labels[i]] = new_array[i] clusterNameDic[labels[i]] = aifutils.make_cluster_with_prototype(g, \ "http://www.columbia.edu/AIDA/DVMM/Clusters/FaceCoreference/RUN00010/"+\ str(labels[i]),entityList[i], sys) #print entityList[a][j] else: dist = np.linalg.norm(firstArray[labels[i]] - new_array[i]) if dist > 1: score = 0.001 else: score = 1 - dist / 2 #score = sigmoid(dist) #print score aifutils.mark_as_possible_cluster_member(g, \ entityList[i],clusterNameDic[labels[i]], score, sys) sys = aifutils.make_system_with_uri( g, "http://www.columbia.edu/AIDA/DVMM/Systems/Face/FaceNet") for key, value in index_category.items(): if key not in NameDetected: continue key = key.replace(' ', '_') #print name2ID[] new_key = key.lower().replace('_', ' ') #print new_key try: #print RPI[parent].keys() #print name2ID[new_key] if name2ID[new_key] in RPI[parent].keys(): print(new_key) #print parent cluster = aifutils.make_cluster_with_prototype(g, \ "http://www.columbia.edu/AIDA/DVMM/Clusters/NamedPersonCoreference/"+\ str(value)+'/'+key,entityDic[key], sys) score = 1 #aifutils.mark_as_possible_cluster_member(g, ,cluster, score, sys) for i in range(len(RPI[parent][name2ID[new_key]])): aifutils.mark_as_possible_cluster_member(g, \ RPI[parent][name2ID[new_key]][i],cluster, score, sys) except KeyError: a = 0 directory = ttl_out + '/' if not os.path.exists(directory): os.makedirs(directory) with open(directory + parent + '.ttl', 'w') as fout: serialization = BytesIO() # need .buffer because serialize will write bytes, not str g.serialize(destination=serialization, format='turtle') fout.write(serialization.getvalue().decode('utf-8'))
def transferAIF(p_id): #for k,p_id in enumerate(parent_dict): # Todo test # if (k<8): # continue # print('k',k,p_id) g = Graph() #load rpi graph if exists if p_id in txt_mention_ttl_list: turtle_path = os.path.join(txt_mention_ttl_path, p_id + '.ttl') turtle_content = open(turtle_path).read() g.parse(data=turtle_content, format='n3') #load and merge cu graph if exists if p_id in cu_ttl_list: turtle_path = os.path.join(cu_ttl_path, p_id + '.ttl') turtle_content = open(turtle_path).read() g.parse(data=turtle_content, format='n3') #load and merge cu graph for instance matching if exists if p_id in cu_ttl_ins_list: turtle_path = os.path.join(cu_ttl_ins_path, p_id + '.ttl') turtle_content = open(turtle_path).read() g.parse(data=turtle_content, format='n3') sys_instance_matching = aifutils.make_system_with_uri( g, cu_pref + 'Systems/Instance-Matching/ResNet152') sys_grounding = aifutils.make_system_with_uri( g, cu_pref + 'Systems/Grounding/ELMo-PNASNET') usc_sys_grounding = aifutils.make_system_with_uri( g, usc_pref + 'Systems/ZSGrounder') #find vision and text entities sbj_all = set(g.subjects()) img_entities = {} keyframe_entities = {} ltf_entities = {} for sbj in sbj_all: sbj_name = sbj.toPython() if cu_objdet_pref in sbj_name: if sbj.__class__ == rdflib.term.URIRef: if 'JPG' in sbj_name: img_id = '/'.join(sbj_name.split('/')[-2:]) img_entities[img_id] = sbj elif 'Keyframe' in sbj_name: kfrm_id = '/'.join(sbj_name.split('/')[-2:]) keyframe_entities[kfrm_id] = sbj elif rpi_entity_pref in sbj_name: if sbj.__class__ == rdflib.term.URIRef and rpi_entity_pref in sbj_name: ltf_entities[sbj_name] = sbj # Done # if p_id in []:#['IC0011TIB']: # continue # print('k',k,p_id) # if (g==None): # print('p_id', k, p_id) ##adding private data to entities for cu grounding #images for key in img_entities: dtype = 'jpg' #instance features ftype = 'instance' data_instance = get_features(key, dtype, ftype) #semantic features ftype = 'semantic' data_semantic = get_features(key, dtype, ftype) #aggregation j_d_i = json.dumps({'columbia_vector_instance_v1.0': data_instance}) j_d_s = json.dumps({'columbia_vector_grounding_v1.0': data_semantic}) entity = img_entities[key] aifutils.mark_private_data(g, entity, j_d_i, sys_instance_matching) aifutils.mark_private_data(g, entity, j_d_s, sys_grounding) #keyframes for key in keyframe_entities: dtype = 'keyframe' #instance features ftype = 'instance' data_instance = get_features(key, dtype, ftype) #semantic features ftype = 'semantic' data_semantic = get_features(key, dtype, ftype) #aggregation j_d_i = json.dumps({'columbia_vector_instance_v1.0': data_instance}) j_d_s = json.dumps({'columbia_vector_grounding_v1.0': data_semantic}) entity = keyframe_entities[key] aifutils.mark_private_data(g, entity, j_d_i, sys_instance_matching) aifutils.mark_private_data(g, entity, j_d_s, sys_grounding) cnt_img = {} cnt_boxO = {} cnt_ltf = {} #add text features, grounding, linking for key in ltf_entities: if key not in grounding_dict: continue entity_name = None USC_GROUNDING = 'usc_vision' in grounding_dict[key][ 'grounding'].values() if not USC_GROUNDING: # print('our grounding') #text features j_d_t = json.dumps({ 'columbia_vector_text_v1.0': grounding_dict[key]['textual_features'].tolist() }) entity_ltf = ltf_entities[key] aifutils.mark_private_data(g, entity_ltf, j_d_t, sys_grounding) #type and name of entity to be linked type_rdf = grounding_dict[key]['type_rdf'] entity_name = grounding_dict[key]['name'] grndg_file_type = grounding_dict[key]['source_type'] if entity_name is None: continue #keep track of entities with same names for avoiding clustering overlap if entity_name in cnt_ltf: cnt_ltf[entity_name] += 1 else: cnt_ltf[entity_name] = 1 clstr_prot_flag = False #cluster obj for entity_ltf not created yet #adding grounding bboxes as new entities for img_id in grounding_dict[key]['grounding']: if img_id == 'system': continue grnd = grounding_dict[key]['grounding'][img_id] for ii, bbox in enumerate(grnd['bbox']): if img_id in cnt_img: #to keep track of cnt of bbox of same image cnt_img[img_id] += 1 else: cnt_img[img_id] = 1 #add grounding bbox as entity score = grnd['bbox_score'][ii] if not USC_GROUNDING: type_eid = cu_grndg_type_pref + f"{grndg_file_type}/{img_id.split('.')[0]}/{cnt_img[img_id]}/ERE" ent_eid = cu_grndg_ent_pref + f"{grndg_file_type}/{img_id.split('.')[0]}/{cnt_img[img_id]}" entity_grnd = aifutils.make_entity(g, ent_eid, sys_grounding) type_assertion = aifutils.mark_type( g, type_eid, entity_grnd, type_rdf, sys_grounding, score) elif USC_GROUNDING: type_eid = usc_grndg_type_pref + f"{grndg_file_type}/{img_id.split('.')[0]}/{cnt_img[img_id]}/ERE" ent_eid = usc_grndg_ent_pref + f"{grndg_file_type}/{img_id.split('.')[0]}/{cnt_img[img_id]}" entity_grnd = aifutils.make_entity(g, ent_eid, usc_sys_grounding) type_assertion = aifutils.mark_type( g, type_eid, entity_grnd, type_rdf, usc_sys_grounding, score) # Done: # 1. add if for the branches for image and keyframe. # 2. add aifutils.mark_keyframe_video_justification # 3. check output # aifutils.mark_keyframe_video_justification(g, [entity, type_assertion], "NYT_ENG_20181231_03", "keyframe ID", # bb2, system, 0.234) # source: HC0005BR6_23 # print(img_id) # Done: # merge usc_grounding dict # add usc_grounding entities and clusters # Test # print("type_assertion",type_assertion, img_id) bb = Bounding_Box((bbox[0], bbox[1]), (bbox[2], bbox[3])) if not USC_GROUNDING: if 'JPG' in type_assertion: imgid = img_id.split('.')[0] justif = aifutils.mark_image_justification( g, [entity_grnd, type_assertion], imgid, bb, sys_grounding, score) # elif 'Keyframe' in type_assertion: imgid = img_id.split('.')[0].split('_')[0] kfid = img_id.split('.')[0].split( '_' )[1] # it should be keyframe image id or keyframe number justif = aifutils.mark_keyframe_video_justification(g, [entity, type_assertion], imgid, kfid, \ bb, sys_grounding, score) elif USC_GROUNDING: imgid = img_id.split('.')[0] justif = aifutils.mark_image_justification( g, [entity_grnd, type_assertion], imgid, bb, usc_sys_grounding, score) else: print( '[Merge Error] in Main Body: the type_assertion is wrong' ) aifutils.add_source_document_to_justification(g, justif, p_id) aifutils.mark_informative_justification(g, entity_grnd, justif) if not USC_GROUNDING: grounding_features = grnd['grounding_features'][ii].tolist( ) instance_features = grnd['instance_features'][ii].tolist() #add private data to this very bbox entity j_d_g = json.dumps( {'columbia_vector_grounding_v1.0': grounding_features}) j_d_i = json.dumps( {'columbia_vector_instance_v1.0': instance_features}) aifutils.mark_private_data(g, entity_grnd, j_d_g, sys_grounding) aifutils.mark_private_data(g, entity_grnd, j_d_i, sys_instance_matching) #### add clusters # Grounding Cluster # Done: filtering about punctuation # translator = str.maketrans(string.punctuation, '_'*len(string.punctuation),'' ) # 'entity_name'.translate(translator) entity_name_tmp = '_'.join(entity_name.split(' ')) entity_name_in_IRI = "".join( x if x.isalpha() or x.isdigit() or x == '_' else '-' for x in entity_name_tmp) # '_'.join(entity_name.split(' ')) #gbbox entity to rpi entity if not USC_GROUNDING: if not clstr_prot_flag: #create cluster if not present clst_eid = cu_grndg_clstr_txt_pref + f"{entity_name_in_IRI}/{cnt_ltf[entity_name]}" clusterObj = aifutils.make_cluster_with_prototype( g, clst_eid, entity_ltf, sys_grounding) clstr_prot_flag = True #cluster current bbox with current ltf_entity score = grnd['men-img-score'][ii] aifutils.mark_as_possible_cluster_member( g, entity_grnd, clusterObj, score, sys_grounding) # Done: add prototype as member aifutils.mark_as_possible_cluster_member( g, entity_ltf, clusterObj, 1, sys_grounding) elif USC_GROUNDING: if not clstr_prot_flag: #create cluster if not present clst_eid = usc_grndg_clstr_txt_pref + f"{entity_name_in_IRI}/{cnt_ltf[entity_name]}" clusterObj = aifutils.make_cluster_with_prototype( g, clst_eid, entity_ltf, usc_sys_grounding) clstr_prot_flag = True #cluster current bbox with current ltf_entity score = grnd['men-img-score'][ii] aifutils.mark_as_possible_cluster_member( g, entity_grnd, clusterObj, score, usc_sys_grounding) # Done: add prototype as member aifutils.mark_as_possible_cluster_member( g, entity_ltf, clusterObj, 1, usc_sys_grounding) # BoundingBox Overlap Cluster (Instance Matching) #gbbox entity to objdet entity for instance matching if not USC_GROUNDING: clstr_prot_b2b_flag = False for jj, img_id_link in enumerate( grnd['link_ids'][ii]): #for all objdet bboxes if img_id_link in img_entities: entity_link_img = img_entities[img_id_link] elif img_id_link in keyframe_entities: entity_link_img = keyframe_entities[img_id_link] else: continue if img_id in cnt_boxO: #to keep track of cnt of bbox overlap for same image cnt_boxO[img_id] += 1 else: cnt_boxO[img_id] = 1 if not clstr_prot_b2b_flag: clst_b2b_eid = cu_grndg_clstr_img_pref + f"{img_id.split('.')[0]}/{cnt_boxO[img_id]}" clusterObj_b2b = aifutils.make_cluster_with_prototype( g, clst_b2b_eid, entity_grnd, sys_grounding) # sys_instance_matching clstr_prot_b2b_flag = True score = grnd['link_scores'][ii][ jj] #IoU of grnd bbox and objdet bbox aifutils.mark_as_possible_cluster_member( g, entity_link_img, clusterObj_b2b, score, sys_grounding) # sys_instance_matching # Done: add prototype as member aifutils.mark_as_possible_cluster_member( g, entity_grnd, clusterObj_b2b, 1, sys_grounding) # sys_instance_matching # Check Point: merged_ttl_D2 # /data/bobby/AIDA/M18_copy/data/merged_ttl/merged_ttl_D2/ # IC0011VEA.ttl # GroundingBox with open(os.path.join(merged_graph_path, p_id + '.ttl'), 'w') as fout: serialization = BytesIO() g.serialize(destination=serialization, format='turtle') fout.write(serialization.getvalue().decode('utf-8')) #sys.stdout.write('Key {}/{} \r'.format(k,len(parent_dict))) sys.stdout.flush()
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_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_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 add_detections_to_graph(g, detections, parent_id, imgid, is_keyframe): str_append = 'Keyframe' if is_keyframe else 'JPG' if is_keyframe: vidid = imgid.split('_')[0] for ii, det in enumerate(detections): label = det['label'] score = det['score'] bbox = det['bbox'] model = det['model'] if score < score_threshold: continue if model == 'coco': sys = system_co elif model == 'voc': sys = system_pa elif model == 'oi': sys = system_oi elif model == 'ws': sys = system_ws elif model == 'coco/J': sys = system_co elif model == 'voc/J': sys = system_pa elif model == 'oi/J': sys = system_oi elif model == 'ws/J': sys = system_ws else: raise for iii, ont_id in enumerate(class2ont[label]): ont_name = ont2name[ont_id] labelrdf = LDC_ONTOLOGY.term(ont_name) if ont_name in ldc_entity_types_new: eid = f"http://www.columbia.edu/AIDA/DVMM/Entities/ObjectDetection/RUN00010/{str_append}/{imgid}/{ii}" entity = aifutils.make_entity(g, eid, sys) entity_dict[eid] = entity type_assertion = aifutils.mark_type( g, eid.replace('Entities', 'TypeAssertions') + f'/{iii}', entity, labelrdf, sys, score) bb = Bounding_Box((bbox[0], bbox[1]), (bbox[2], bbox[3])) if is_keyframe: justif = aifutils.mark_keyframe_video_justification( g, [entity, type_assertion], vidid, imgid, bb, sys, score) else: justif = aifutils.mark_image_justification( g, [entity, type_assertion], imgid, bb, sys, score) aifutils.add_source_document_to_justification( g, justif, parent_id) aifutils.mark_informative_justification(g, entity, justif) #aifutils.mark_private_data(g, entity, json.dumps({}), sys) #if ont_name.split('.')[0] in allowed_to_have_name: # aifutils.mark_name(g, entity, class_names[label].split('(')[-1][:-1]) else: eid = f"http://www.columbia.edu/AIDA/DVMM/Events/ObjectDetection/RUN00010/{str_append}/{imgid}/{ii}" event = aifutils.make_event(g, eid, sys) event_dict[eid] = event type_assertion = aifutils.mark_type( g, eid.replace('Events', 'TypeAssertions') + f'/{iii}', event, labelrdf, sys, score) bb = Bounding_Box((1, 1), image_shape[imgid]) if is_keyframe: justif = aifutils.mark_keyframe_video_justification( g, [event, type_assertion], vidid, imgid, bb, sys, score) else: justif = aifutils.mark_image_justification( g, [event, type_assertion], imgid, bb, sys, score) aifutils.add_source_document_to_justification( g, justif, parent_id) aifutils.mark_informative_justification(g, event, justif)
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")
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")