As Linked Data available on the Web continue to grow, understanding their structure and assessing their quality remains a challenging task making such the bottleneck for their reuse. ABSTAT is an online semantic pro ling tool which helps data consumers in better understanding of the data by extracting data-driven ontology patterns and statistics about the data. The SHACL Shapes Constraint Language helps users capturing quality issues in the data by means of constraints. In this paper we propose a methodology to improve the quality of different versions of the data by means of SHACL constraints learned from the semantic pro les produced by ABSTAT.
Million of facts describing entities such as people, places, events, lms, etc., are
stored in knowledge repositories. In the Semantic Web, knowledge is encoded
into graphs represented using the RDF data model1. Nodes in these graphs
represent entities or literals, while arcs represent relations between entities and
between entities and literals, whose semantics is speci ed by RDF properties.
Entities and literals are usually associated a type, i.e., respectively a class or a
datatype. The sets of possible types and properties are organized into schemas
or ontologies, which de nes the meaning of the terms used in the knowledge
base through logical axioms. Often KGs are very large and are continuously
evolving, as an example we can mention Linked Data which has evolved with
roughly 1; 184 data sets as of April 20182. However, understanding and exploring
the content of large and complex knowledge bases is very challenging for users
[
As the number and size of published KGs is increasing, the need for methodologies and tools able to support the quality assessment of such datasets increase as well. Many data producers take care about the quality of the data they publish resulting in many data sets in the LD cloud that are of a high quality. However, there are also many data sets, which are extracted from unstructured
or semi-structured information being vulnerable for quality issues [
In this paper we propose an approach for improving the quality of di
erent versions of knowledge graphs by means of ABSTAT [
SHACL3 (Shapes Constraint Language), is a highly expressive language used to write constraints for validating RDF graphs recommended by the W3C. Constraints are written in RDF. In this paper we show not only how ABSTAT patterns encode valuable information to evaluate and improve the quality of knowledge graphs (RDF data sets), but also how this information can be translated into SHACL pro les that can be validated against the data. More precisely, we introduce the rst methodology to build SHACL pro les using data-driven ontology patterns extracted automatically from the data. These SHACL pro les can be derived automatically, re ned by the users (also with the help of information provided by the semantic pro ling tool) and then validated automatically using a SHACL validator. The overall idea is that ABSTAT pro les and SHACL pro les can be used in combination to improve the quality of RDF data sets along time.
Our contributions can be summarized as follows: (i) We provide a methodology for the quality assessment and validation among di erent versions of a dataset. In particular we propose an approach to detect quality issues in the data by means of cardinality statistics, (ii) Represent ABSTAT semantic proles into SHACL language and (iii) Use SHACL pro les as templates for quality detection.
The rest of the paper is organized as follow: Related work are discussed in Section 2. In Section 3 we introduce the methodology for improving the general quality of the data sets. In Section 4.1 we describe how pattern-based pro les can support data quality assessment of the data. We rst introduce ABSTAT and the generated pro le consisting of data-driven ontology patterns. We then describe how to transform ABSTAT pro les into SHACL language in order to use them as templates for validation. An example of how such approach can be applied into DBpedia is given in Section 5 while conclusions end the paper in Section 6. 2
The identi cation of quality issues has been recently studied in RDF data
sets. The most straightforward way to represent constraints is the use of OWL
24 by means of three axioms: owl:minCardinality, owl:maxCardinality, and
owl:exactCardinality on ObjectProperty as well as on DatatypeProperty.
However such kind of declaration is optional and consistency with the data is not
ensure. Especially it is very di cult to evaluate consistency when relations are
not explicitly stated such as in the case of lightweight ontologies. The
expressiveness of OWL 2 is limited also to express integrity constraints [
The quality of DBpedia as one of the most known and used data set of the
LOD cloud has been studied in di erent works such as [
Authors in [
The problem of mining cardinality bounds for properties in order to discover
structural characteristics of knowledge bases and assess their completeness is
introduced by [
metrics either procedurally, through Java classes, or declaratively, through a
quality metric. In [
With respect to the related work described in this section, this paper di ers in several ways: i) it provides an iterative way for the improvement of quality over upcoming versions of the data; ii) it introduces the concept of SHACL pro les which serve as templates for validation of the data; and iii) proposes the use of minimal ontology-patterns to detect quality issues in the data. 3
In this section we introduce the methodology of the approach that can learn validation rules upon semantic pro les. For representing such rules we propose to use SHACL (Shapes Constraint Language), a versatile constraints language for validating RDF. Such rules are used as templates for detecting quality issues for the upcoming versions of data. The process of validating the quality of di erent versions of the data set through the use of SHACL pro les is given in Figure 1. Validation of the data set could be done in the following phases:
Phase I: As a rst step, for a data set (D1) semantic pro les (Ap1) are
generated with the help of ABSTAT (Section 4.1). Such semantic pro les allow
users to detect quality issues in the data [
Phase 2: In order to assess quality issues in the data set (D1), a custombuilt converter was implemented which transforms semantic pro les into SHACL mappings (Sp1) (Section 4.3). To the best of our knowledge in the state-of-the-art there are no converters to support such transformation.
Phase 3: SHACL pro les specify severities (sh:severity sh:Warning) to identify non-critical constraint violation for those properties for which the maximum cardinality is higher than twice the average (Section 4.4). We chose such threshold in our experiments because we wanted to verify as much as possible cases which violate the quality of the data. Such threshold is a tunable parameter.
Phase 4: The domain expert takes such report and veri es if the cases identi ed as Warning are real violations or not. Gradually checking such cases the user updates the SHACL pro les (Sp1'), if the violations are not real, or otherwise updates the data set. As a rst step in validating our approach we check manually if violations are real or not. We are investigating methods how to capture such real violations automatically.
Phase 5: When a di erent version of the dataset is available (D2) the domain expert can directly validate the new data against the constraints Sp1' and use semantic pro les for exploring the data.
Such process iterates any time a version of the data comes. In such a way the quality of the upcoming versions of the data improves over time as well as the quality of the data set itself is improved as in Figure 1.
In this section we show how to apply the methodology by describing each phase and presenting a real example. 4.1
In the following we describe the main features of ABSTAT bringing the main
de nitions from our previous paper [
Patterns are abstract representations of Knowledge Patterns, i.e., constraints
over a piece of domain knowledge de ned by axioms of a logical language, in the
vein of Ontology Design Patterns [
A piece of a subtype graph is shown in Figure 2. Two branches of the concept (classes) hierarchy are shown with respect to Thing class. The rst branch has the subtype relation between Agent, Person, Artist, MusicalArtist, Instrumentalist and Guitarist while the second one has the subtype relation between Place, PopulatedPlace and Settlement. Consider in the data set the following triples: <dbo:Kurt Cobain dbo:birthPlace dbo:Washington>, <dbo:Kurt Cobain rdf:type dbo:Guitarist>, <dbo:Kurt Cobain rdf:type dbo:Person>, <dbo:Washington rdf:type dbo:Settlement> and <dbo:Washington rdf:type dbo:PopulatedPlace>. From the triples above, in the data Kurt Cobain has two types, Person and Guitarist, while the resource of Washington has the types PopulatedPlace and Settlement. The approach of ABSTAT, which considers only the minimal type, extracts the pattern <dbo:Guitarist, dbo:birthPlace, dbo:Settlement> as Guitarist is the minimal concept between Person and Guitarist for the resource of Kurt Cobain. While the concept Settlement is the minimal type because is a subtype of PopulatedPlace. For the triple with birthDate as predicate ABSTAT could extract the pattern <dbo:Guitarist, dbo:birthDate, xmls:Date>. Among patterns ABSTAT is able to extract also other statistical information such as: { frequency which shows how many times this pattern occurs in the data set as minimal type pattern. { instances which shows how many times this pattern occurs based on the ontology, regardless of pattern minimality. In other words, this number tells how many relation instances (i.e., relational assertions) are represented by the pattern, by counting also the relation instances that have a more speci c pattern as minimal type pattern. For example, if we have two patterns (C; P; D) and (C; P; D0) with D being a subtype of D0, (C; P; D) is more speci c than (C; P; D0) (can be inferred using the subtype graph); thus, instances of (C; P; D0) include occurrences of (C; P; D) and (C; P; D0) itself. { Max (Min, Avg) subjs-obj cardinality is the maximum (minimum, average) number of distinct subjects associated with a same object through the predicate p, with subjects and objects belonging to respectively the subject type and the object type. { Max (Min, Avg) subj-objs is the maximum (minimum, average) number of distinct entities of type is subject position linked to a single entity of the type in the object position through the predicate p.
Figure 3 shows the semantic pro le generated by ABSTAT for the example
above. The statistical information can be understood as below. Frequency shows
that the pattern <dbo:Guitarist, dbo:birthPlace, dbo:Settlement> occurs 36 times
in the data set. The number of instances shows that there are 50 relational
assertions that are represented by this pattern, regardless of minimality (e.g.,
here we sum relational assertions that have (Guitarist, birthPlace, City) as
minimal type pattern). Max (Min, Avg) subjs-obj cardinality is the maximum
(minimum, average) number of distinct entities of type Guitarist linked to a
same entity of type Settlement through the predicate birthPlace. There are at
most 6 (minimum 1 and in average 1) distinct entities of type Guitarist linked
to a single entity of type Settlement. Max (Min, Avg) subj-objs is the maximum
(minimum, average) number of distinct entities of type Settlement linked to a
single entity of type Guitarist through the predicate birthPlace. Notice that
occurrences is given also for types and predicates. The type Guitarist occurs
151 times, the predicate birthPlace occurs 1 168 459 and the type Settlement
occurs 238 436 times.
Shapes Constraint Language (SHACL) since July 2017 is a W3C
recommendation language for de ning constraints on RDF graphs. The scope of SHACL is
primarily validation but it can be extended to data integration, code generation
and interface building. Validating RDF graphs is done against a set of shapes. A
SHACL processor has two inputs: a data graph that contains the RDF data to
validate and a shapes graph that contains the shapes [
Figure 4 shows the syntax of the example pattern in Figure 3 into the SHACL language (Phase 2 of the methodology). Not all the information in the semantic pro le produced by ABSTAT can be represented in SHACL. Only a subset of the information such as the minimum and maximum cardinality for both subj-objs and subjs-obj can be represented. We can not represent the information about the frequency of types, predicates, patterns, the occurrence and the average cardinality for both subj-objs and subjs-obj. For such statistics we will extend SHACL in the future as described in Section 6.
The semantic pro le produced by ABSTAT can be transformed into SHACL by representing each pattern (C; P; D) (in parenthesis we map such process with the example in the Figure 4) as follows: { For each type C (Guitarist) we extract all patterns with C (Guitarist) as the subject type. The subject type C (Guitarist) is mapped into a node shape (sh:NodeShape) targeting the class. { The property P (birthPlace or birthDate) is mapped into a property shape (sh:property) with a value for sh:path equal to the property.
If for all patterns (C; P; Z), (Guitarist, birthPlace) Z (Settlement or City) is a class, then a "global" sh:path speci cation is added that speci es the sh:nodeKind as an sh:IRI. If for all patterns (C; P; Z), Z (xmls:date) is a datatype, then a "global" sh:path speci cation is added that speci es the sh:datatype as a rdfs:Literal. Observe that this step is executed only for the rst pattern with C (Guitarist) as subject type and P (birthPlace, birthDate) as property. a "local" sh:path speci cation is added to specify characteristics for each object type Z (Settlement, City) for the property P (birthPlace). For each path P (birthPlace), Z (Settlement, City), cardinality constraint components are set, namely sh:minCount, sh:maxCount. sh:inversePath property is used to describe the inverse cardinality for the properties. 4.4
In this section we describe how the domain expert can apply some heuristics in the semantic pro les and use SHACL to validate the data (Phase 3).
For all patterns for which the number of maximum cardinality is higher than twice the average we generate a severity report sh:Warning. We put such threshold in order to capture as much as possible cases where the quality might be a ected. For those patterns we use SHACL-SPARQL to generate the entities that violate such constraints as in the Figure 5. 5
In the following we consider the triple patterns extracted by ABSTAT in Figure 6, which contain descriptive information about companies in DBpedia 2015-10. Note that the triple patters in the gure are just a sample of the patterns containing dbo:Company in the subject type. In this example we also have xed the predicate which is dbo:keyPerson. As described above apart from triple patterns, ABSTAT is able to produce also statistics that describe some characteristics about the data. The type Company is used in the data 51 898 times while the predicate dbo:keyPerson is used 31 078 times. The rst triple pattern <dbo:Company, dbo:keyPerson, owl:Thing> occurs 18 710 times in the data. While the number of instances having such pattern including those for which the types Company, Thing and the predicate keyPerson can be inferred is 29 884. Moreover ABSTAT is able to describe some characteristics of the data (in Figure 6) as below:
R1. There are about 5 268 distinct entities of type Company linked to a single entity of type Thing through the predicate keyPerson (Max subjs-obj).
R2. For each entity of type Company there exist at least one value for the predicate keyPerson (Min subjs-obj).
R3. The number of distinct entities of type Thing linked to a single entity of type Company through the predicate keyPerson is 23 (Max sub-objs).
R4. For each entity of type Thing there exist at least one entity of type Company for the predicate keyPerson (Min sub-objs).
R5. The predicate keyPerson is an object property thus all triples which have this as predicate take an entity in the object (the OP symbol in the predicate eld of the pattern).
R6. The domain and range of the property keyPerson is the union of the types in the subject position and the union of the types in the object position of triple patterns that have keyPerson as predicate.
By looking at the descriptive information gained from ABSTAT in the
example above, we can see that they reveal quality issues in the data. R1, R2, R3
and R4 are known as cardinality constraints (used to specify a minimum and
maximum bound for relationships with properties that an entity can have [
Similarly, we could identify such quality issue for the triple pattern <dbo:Company, foaf:homePage, owl:Thing >. The max cardinality subjs-obj is 27 while the minimum and the average cardinality is 1. Looking at the triples from which ABSTAT derived the above pattern, there are di erent entities of the type Company linked with the predicate homepage of the FOAF vocabulary to the http://www.centurylink.com webpage which are linked with instances of type Thing. Some example of such kind of triples are the following: <dbr:Embarq Florida foaf:homepage http://www.centurylink.com/> <dbr:Central Telephone foaf:homepage http://www.centurylink.com> foaf:homepage <dbr:United Telephone Company of Kansas http://www.centurylink.com>
In the version of DBpedia considered in this paper we did not nd any violation for the R5. Such violations are easy to be identi ed in the version of DBpedia 3.9 with Infoboxes e.g., birthDate is used as an object property (with the dbp namespace) also as a datatype property (with the dbo namespace).
The violation of the R6 is caused by triple patterns of the form <dbo:Company, dbo:keyPerson, dbo:Company>. In the ontology of DBpedia, the range of dbo:keyPerson is Person but in the data such property is used also with instances of the type Company (254 patterns), Organization (308 patterns), University (15 patterns), Bank (13 patterns) or Software (7 patterns) etc. In the other example the semantics of the predicate foaf:homepage implies the domain to be a Thing while the range should be a Document5. Such restriction is violated by the use of such predicate in DBpedia 2015-10.
In this work, we limit ourselves to mainly study the violation of cardinality constraints and integrity constrains described above because of the impact that they have in the quality analysis of the data. Most of the Linked Data quality assessment, require users to have knowledge about the structure of the data whereas we aim to provide users a method to capture quality issues by means of identifying violated constraints against semantic pro les produced by ABSTAT.
In our experiments we use DBpedia as one of the most used data set covering di erent domains and being one of the most curated data set in the LOD cloud. However other data sets being a single-topic data set such as media, life science, etc. data sets are planed to be considered in our future experiments. 5 http://xmlns.com/foaf/spec/#term_homepage
In this paper we propose a methodology for assessing the quality of data sets and their versions by means of an ontology pattern pro ling tool. For each data set, ABSTAT generates a semantic pro le that describes some characteristics about the data. The semantic pro les are then transformed into SHACL for the validation of constraints. Cases where the cardinality between max and average have a high imbalance are reported as warnings. A user veri es further such warnings and consequently updates the data set and the SHACL pro le. Although this research is in the beginning, samples extracted from DBpedia have shown that it is an e ective way to capture and improve quality issues over time.
As a future direction we plan to implement the full pipeline for the generation of SHACL pro les and SHACL validators and make the code available. We plan to extend SHACL by including also other statistical information produced by ABSTAT in order to apply sophisticated heuristics to capture quality issues such as including frequency and occurrence of a pattern. Moreover, we plan to run the experiment in large scale, thus including more data sets that belong to di erent topical domains and make an analysis of the most frequent quality issues.
Another interesting future direction is the investigation of inconsistencies or quality issues over time for those data sets that have versioned ontologies. The semantic pro les produced by di erent versions of the data and the ontology can be compared by exploring summaries while SHACL pro les can be used as templates for the veri cation of errors found in the other version of the data.
This research has been supported in part by EU H2020 projects EW-Shopp - Grant n. 732590, and EuBusinessGraph - Grant n. 732003. This work will be published as part of the book \Emerging Topics in Semantic Technologies. ISWC 2018 Satellite Events. E. Demidova, A.J. Zaveri, E. Simperl (Eds.), ISBN: 978-3-89838-736-1, 2018, AKA Verlag Berlin".