As more and more knowledge graphs (KG) are published in the Web, there is a need of tools for abstracting their content for their producers to verify their result, and for their consumers to use it. This implies showing the schema-level patterns instantiated in the graph, with the frequency with which they are instantiated. A profile represents this information. In this paper, we propose a new type of profile that we call TT profile, for Types and Terms profile. It shows the used Types and predicates, and also the used Terms because of their paramount importance in most of KGs, especially in the Cultural Heritage (CH) domain. We present an algorithm for building a TT profile from an online KG's assertional part, and we report on experiments performed over a set of CH KGs.
RDF triples (last column) in this KG for which the predicate dbo:country relates a subject of type dbo:Location to an object of type dbo:Country, which informs us that we can query locations and their associated countries. Figure 1 (right) presents the Basic Graph Pattern (BGP) able to compute an ABSTAT AP representing its instances, with n its frequency (number of its instances in the KG). Edges labeled with “a” represent the predicate rdf:type.
ABSTAT returns thousands of APs just for the predicate dbo:country from
this dataset, several of them representing the same facts in the KG. For instance,
dbo:Location and schema:Place in Figure 1 are probably both types of the
subjects of predicate dbo:country that have objects of type dbo:Country, since the
two APs have exactly the same frequency (i.e., 560,532). In other words, if the
BGP in Figure 2 (a) was instanciated in the KG, then ABSTAT would generate
four APs (cartesian product of subject’s and object’s types), all with the same
frequency n. For representing each fact in the KG with only one AP, we propose
to deal with APs where predicates relate not just types but sets of types, as
in Figure 2 (a). Moreover, to the best of our knowledge there is no tool that
highlights not only the types of the subject and object of a predicate, but also
the terms used for objects in the KG. It is one thing to indicate that there are
instances of crm:E22_Man-made_Object in the graph, but the fact that it contains
information about coins, or burials, or garments, is much more interesting and
precise. In KGs that use the CIDOC Conceptual Reference Model 2 (hereafter
CIDOC), this information is carried by terms, more precisely by URIs described
in some thesauri, such as http://nomisma.org/id/coin for instance. This is the
case because, quoting [
purposes. This means that CIDOC-based KGs generally employ various sets of terms, which provide at least as much meaning as the used CIDOC types and predicates. For taking this into account, we propose abstract patterns showing terms used in the graph, as illustrated in Figure 2 (b), where ti denotes the instances of the variable ?t and the edge labeled with “prefLabel” represents the situation where the variable ?o is instantiated by a term and ?t by a label of that term. Detecting this situation depends on how are implemented the vocabularies. In this paper we consider those implemented with SKOS3.
To sum-up our contribution, we deal with KGs that are sets of assertional knowledge, whose intentional part is formally defined by existing RDFS or OWL ontologies, and who contain instances of SKOS concepts, defined in existing SKOS thesauri. Given that the ontologies and thesauri used are not necessarily accessible online for programs, we present and discuss a program called TTProfiler to build a set of Types and Terms (TT) APs that we call a profile, by querying its online SPARQL endpoint4. The rest of this paper is organised as follows: in Section 2, we provide definitions for TT APs and profiles. In Section 3 we present the TTProfiler algorithm. We report in Section 4 our uses of its implementation on various online CH KGs. We conclude in Section 5. 2
We use Description Logics (DL) [
we find in DBpedia Person(dbr:Ringo_Madlingozi), skos:Concept(Category:1964) and dct:subject(dbr:Ringo_Madlingozi, Category:1964).
Our aim is to give an abstract of the ABox content, which in the Web of
data is in general far bigger than the TBox. We work with the asserted KG
(or ABox), not with the version one gets by applying a reasoner. By default,
SPARQL endpoints do not perform entailments. We put in evidence all the
types and predicates appearing in the ABox, whatever the ontologies they
belong to, so we do not limit ourselves to only one given ontology. We also want
to highlight the SKOS concept instances appearing in the ABox. To do so we
look for skos:Concept instances or subjects of skos:prefLabel, and we also look
for declared prefixes that correspond to some known thesauri. We do not use
the ontologies and thesauri in the algorithm presented in this paper. When
publicly available, they can be used latter on, together with profiles, for completing
them. There may be cases in which the TBox is limited to few ontologies that
are consistent by themselves and semantically compatible with each other. In
those rare cases, a reasoning step combining the TBox and ABox could also be
performed before or during the profile generation. This is out of the scope of this
paper, because we want our proposal to work on the online Web, which presents
too much uncertainty about the quality of the ontologies used (they are not even
guaranteed to be accessible online for programs). This is why we limit our scope
to the ABox content without considering the TBox, leaving it to other services
to process the ontologies and thesauri for enriching the profile information
afterwards, when needed. The algorithm presented in this paper builds a profile
of the given ABox A, that is composed of TT AP (Types and Terms abstract
patterns), which are triples whose subjects and objects are sets, as defined in
Definition 1. In [
Definition 1 (TT Abstract Pattern). Given an ABox A, a TT abstract pattern of A is a triple (C; P; D) such that C is a set of types in A, P is a predicate in A, and D is either a set of types in A or a set of terms appearing in A. Here a term is a string literal, label of an instance of skos:Concept. A TT abstract pattern (C; P; D) represents a fact P (a; b) of A if: – the entity a is an instance of each type in C (i.e., C(a) 2 A for C 2 C), and – the entity b is an instance of each type in D (i.e., D(b) 2 A for D 2 D) or the entity b is an instance of skos:Concept and its prefLabel is in D (i.e., skos:Concept(b) and skos:prefLabel(b; t) and t 2 D).
This definition can be declined in various versions. For instance, the subject
and object of an AP could be generalised to types not actually appearing in A
but defined using T , as owl:Thing, rdfs:Literal and so-called minimal types
used in [
There are many ways to define interesting statistics of a KG’s assertional part. We may consider the global number of assertions C(a) for each type C, the global number of assertions P (a; b) for each predicate P , the global number of assertions P (a; b) for each SKOS concept b appearing in A... In this paper, we deal with the frequency of a TT AP, that is how many facts of A it represents. We call weight the function that associates with (C; P; D) its frequency in A. Definition 3 (Weight of a TT abstract pattern). The weight of the TT abstract pattern (C; P; D), denoted !((C; P; D)), is the function that associates with (C; P; D) its frequency in A. !((C; P; D))= jfP (a; b), P (a; b) 2 A and P (a; b) is represented by (C; P; D) according to Definition 1gj.
Moreover, for the sake of drawing clearly the TT profile as a graph, we aim at grouping the sets of types in such a way that each type appears in only one set (or node). For instance if we have in a TT profile P the TT APs A1 = (fC1; C2g; P1; fC3g)), A2 = (fC1; C3g; P2; fC4g); A3 = (fC1g; P3; ft1; t2g) and A4 = (fC3g; P3; ft1; t3g), with !(A1) = 20, !(A2) = 18, !(A3) = 100 and !(A4) = 50, then we merge sets fC1; C2g; fC3g; fC1; C3g and fC1g into a maximal set fC1; C2; C3g and sets ft1; t2g and ft1; t3g into a maximal set ft1; t2; t3g, which gives the representation shown in Figure 3.
Searching for maximal sets is searching for the components of the graph formed by the profile’s nodes (subjects and objects of TT APs), with an edge connecting two nodes if and only if there is a non-empty intersection between these two nodes. The union of component’s nodes is a maximal set. Computing the components of a graph is generally done by a linear depth-first search, but in Algorithm 1 we incrementally compute the maximal sets ' during the TT profile building. For the profile visualisation, maximal nodes can be represented by one of their types or terms, and the others can be shown on demand. As shown in Figure 3, edges are annotated with the corresponding AP and its weight.
We can now state our problem as follows: Given the assertional part of a knowledge base K = (T ; A), how to efficiently generate and visualise a TT profile of A? 3
TTProfiler Algorithm TTProfiler computes a TT profile of an ABox A following a three steps procedure: 1) basic abstract patterns and statistics recovery, 2) TT profile computing, and 3) TT profile visualisation structure building.
Step 1: Basic abstract patterns and statistics recovery. We recover all basic abstract patterns (C; P; D) with w, their frequency, i.e. the number of instances of (C; P; D) in A (line 1). An assertion P (a; b) in A is said to be an instance of the abstract basic pattern (C; P; D) if and only if a is of type C in A (i.e., C(a) 2 A) and b is either of type D or a term of a thesaurus.
Step 2: Profile computing. To fit Definitions 1 and 2, for each predicate appearing in a basic abstract pattern we group all types that have common instances (lines 5-11), and we also group terms for subjects having the same type (lines 12-14). For this last case, we associate to the predicate a weight equals to the sum of the weights computed in Step 1. With the resulting weighted TT APs, each fact P(a,b) is represented by only one pattern. Each computed TT AP is added into the TT profile P (line 15). We also incrementally compute the set ' of maximal nodes, incorporating in it the nodes C and D (that are sets of types or terms) (line 16). The incorporation of a node in ' consists in grouping its elements with other nodes containing them, as explained in Section 2 (cf. the example illustrated in Figure 3).
Step 3: Profile Visualisation structure computing. In this last step, for each weighted TT abstract pattern we replace its subject and object by their corresponding maximal node in ' (lines 19-20) and we add the resulting triple to the Profile Visualisation structure P V .
Regarding the complexity, Step 1 consists in querying the KG, so it depends on the SPARQL endpoint and the network capacities; Step 2 is linear in the number of predicates and quadratic in the number of basic abstract patterns computed in Step 1; Step 3 is linear in the number of TT abstract patterns. 4
TTProfiler, whose code is published in Github (see Section 1), is devised to apply to KGs that can be queried online via a SPARQL endpoint. This requires Algorithm 1 TTProfiler: Types and Terms Profiler then Input: The ABox A of a knowledge base K = (T ; A) Output: The TT profile P of A and its visualisation structure P V //Step 1: basic abstract patterns extraction from A and statistics computation 1: Let R = f((C; P; D); w)=(9P (a; b) 2 A) ^ C(a) 2 A ^ (D(b) 2 A _ (skos : Concept(b) ^ skos:pref Label(b; D)))g where w is the number of instances P (a; b) in A for (C; P; D) //Step 2: TT profile computing: grouping types and terms in sets 2: Let P = fP=(9((C; P; D); w) 2 R)g . P is the set of predicates in R 3: P ;, ' ; . ' is a set of maximal sets of types or terms 4: for (P 2 P) do . grouping types and terms by predicates 5: for ((C1; P; D1); w1) 2 R do 6: C fC1g, D fD1g, w w1 7: for ((C2; P; D2); w2) 2 R ^ ((C1 6= C2) _ (D1 6= D2)) do 8: if (C1 6= C2) ^ (D1 = D2) ^ (8P (a; b) 2 A : C1(a) 2 A ^ C2(a) 2 A)
C C [ fC2g . group the types of subjects if (D1 6= D2) ^ (C1 = C2) ^ (8P (a; b) 2 A : (D1(b) 2 A ^ D2(b) 2 A) 9: 10:
then 11: to carefully write the SPARQL queries in Step 1 because of fair use policies applied by public SPARQL endpoints. Moreover, as already said about the time complexity, Step 1 of computing a TT profile depends on the configurations of the SPARQL endpoint and the network capacities. Considering only the client side computation (Step 2 and Step 3), on small graphs, less than 1; 000; 000 triples, the TT profile generation takes about 0.06 seconds. For 91; 000; 000 triples it takes 1.15 seconds. TTProfiler is implemented in Java using the Jena library to query the public SPARQL endpoints. It was run on Windows 10 with an Intel core i7 processor and 32 GB of RAM.
We design this program as part of a French CH project called SESAMES5 and we test it with the archaeological KGs grouped in OpenArchaeo6. Those graphs are generated from legacy databases, based on a common model which is a small excerpt of the CIDOC and its extensions. Even with such a restricted ontology, all types and predicates do not have instances in all KGs, so the visual query tool that OpenArchaeo provides could be complemented by the display of TT profiles to show what can be asked. In addition, the producers of these graphs use the TT profiles to inspect the results of the KG automatic generation, which is based on mappings expressed with tools like Ontop and X3ML. KG producers exactly know which predicates, types and terms should appear in the TT profiles, and can therefore easily detect anomalies in their mappings.
Besides the KGs in OpenArchaeo, we looked for other graphs using the CIDOC CRM and offering a SPARQL API usable by an application. Of those found, many are not always online and many do not answer to counting SPARQL queries of Step 1. We present in Table 1 nine graphs that are currently7 capable of answering the required queries. Seven of them are from OpenArchaeo (Kition, Iceramm, Arsol, Epicherchell, Outagr, Rita, and Aerba) and are rather small, while the Smithsonian’s8 and Doremus’s9 graphs are of different designs, use English terminologies, and are much larger. Doremus contains multilingual labelsTable 1 shows the number of edges and nodes in KGs, the number of distinct types/terms appearing in P, the number of TT APs (i.e., jPj) and maximal nodes (i.e., jP V j). Although the set of basic abstract patterns is already a condensed representation of the original graph, it can be too large to be easily visualised, hence the grouping of types and terms and the use of the notion of maximal node, which allows us to display graphs with less nodes, as shown in the last two columns of Table 1. Figure 4 gives an example of the graph visualisation offered to end-users.
Table 2 shows that the nine KGs use the CIDOC and eventually one or more of its extensions (CRMsci, CRMarch, CRMba). Doremus uses the so-called Erlangen implementation of the CIDOC (denoted ecrm). In addition, these KGs use terms of thesaurus, the PACTOLS 10 for OpenArchaeo KGs, and an internal vocabulary for Doremus. When thesauri are used, the number of the terms is far larger than that of types. Concerning the predicates instantiated in each KG, here again, all KGs use the CIDOC or its extensions. As can be noticed, CRMba is used by ArSol in OpenArchaeo for one type and not for any predicate: this is because the extensions are attached to CIDOC by subsumption links. So, one can use extension classes with predicates that are defined in CIDOC. In general both types and predicates of extensions are used in the tested KGs.
7 June, 2021
We present in Figure 4 a visualisation of a small profile, that of Epicherchell. In this graph, nodes suffixed by et_al are sets of terms and colours denote namespaces (e.g. blue for CRMsci). A click on an edge, here the predicate P4_has_time-span, displays its subject and object. Node’s content is also displayed on demand, for instance in the bottom of the figure one have selected the node autel_et_al. These terms are used to describe the usage of objects. The profile shows that not only the objects are characterised by the type E57_Material with the predicate P45_consists_of, but it also contains the set of terms that are used in the KG for each material, with the node albatre_et_al that appears as object of the same property. 5
Compared to works aiming at discovering the schema of a graph, or extracting
modules or constraints from KGs, our problem is much simpler. TT profiles
can be seen as a special kind of KG summaries as described in the recent and
comprehensive surveys on KG summarisation [
With respect to ABSTAT, our proposal can be analysed with regard to
Thomas Kuhn’s six criteria for characterising successful improvements in
scientific theories [
As already mentioned, TTProfiler is used by OpenArchaeo’s KG producers
who know which predicates, types and terms should appear in the TT profiles
and can detect anomalies in their KG production process. TT profiles are
therefore a support to the automatic generation of KGs. This interesting aspect is
also cited in [
A TT profile can be used for supporting humans in discoverins KG content to retrieve the information they want. We are currently designing a Web visualisation tool for interactively showing the KG profile, and we plan to provide also an API for applications to query the profile. We are also studying ways of completing the TT profile with information from the ontologies, by extracting the minimal parts of ontologies useful for the profile’s types and predicates. Another need demonstrated with our experiments is to build summaries from the profile for huge KGs. We would like to design algorithms for building summaries as sets of k connected nodes, for a given number k.
Acknowledgements: This work is supported by the ANR-18-CE38-0009 (“SESAME”). The authors thank Zilu Yang for her work on the Web visualisation tool.