Towards SHACL-based Knowledge Graph Transformation of Visual Domain Knowledge

1 Introduction and Motivation

The setup and optimisation of industrial production processes, such as, for example, high-pressure die casting, heavily rely on the expert knowledge and experience of a few individuals within a company. Consequently, domain knowledge often remains personal property rather than a shared company asset, creating a dependency on specific personnel. Despite companies’ quality management standards, this valuable knowledge is frequently undocumented and undigitised, making it inaccessible to the broader workforce. This lack of effective knowledge management and transfer hinders resource-efficient, green production of advanced products, such as complex die-casting parts, especially in times of skilled labour shortages. It has therefore become a pressing issue for industries to find a low-threshold, minimal-effort way for experts to digitise and share their knowledge, making it machine-readable, accessible and usable also for non-domain experts. A toolchain that achieves this goal should include a highly accessible tool for experts to document their domain knowledge. Examples of such tools are Conceptboard ¹, Microsoft Whiteboard ², and Infinity Maps ³.

In the present paper, we will use Infinity Maps due to their rich JSON exporting capabilities. Additionally, a technology and/or database that is able to store knowledge in a structured form is of utter importance. In our case, the output of the toolchain is a knowledge graph (KG) in RDF format. The envisaged toolchain is outlined in Fig. 1.

Contribution..

We design a transformation pipeline from Infinity Maps to a structured RDF graph, based on the SHACL standard⁴. Features include:

2 From Domain Knowledge to Knowledge Graph

Step 1: Visual modelling by schema..

The first step in our pipeline is to organise and gain an overview of all available expert and domain knowledge, which comes in various formats like PNG, PDF, CSV files, emails, and interviews. Infinity Maps excels in visualising and organising this unstructured information. It allows the creation and connection of cards into tree-like hierarchies, a feature we use extensively to efficiently manage and structure our knowledge base. Once an overview on all available knowledge sources has been attained, Infinity Maps can also be used to combine and organise what information was learned from these sources. To this end, we designed a loose schema based on the gathered information and visually modelled this domain knowledge accordingly.

Step 2: Visual modelling by ontology..

In the later stages of visual modelling, we developed an ontology for the envisaged KG, thereby clarifying the modelling guidelines. We utilised tags and tree-like hierarchies within Infinity Maps to denote relationships between entities and label cards accordingly. These tags and hierarchical logic subsequently guides the transformation process from Infinity Maps to the KG.

A significant drawback of Infinity Maps is the absence of dynamic links between cards. Although each card has a unique URL and can be referenced via hyperlinks, these links are static text and can easily break during the Map authoring process. To maintain simplicity for human readability, we opted to cross-reference tagged cards by ensuring that each combination of card label and tag remains unique throughout the entire Infinity Maps project.

Due to this limitation in dynamic linking, we anticipate the appearance of duplicate entities and errors in triplets when converting from Infinity Maps to a KG. This necessitates additional constraints and rules for a successful transformation.

Step 3: Transformation by constraints..

Infinity Maps allows exporting each Map to JSON format. We transform these JSON structures to a KG using Python code and shapes implemented in SHACL. This procedure is described in much more detail in Section 3.

Closing the loop..

From the KG, new domain knowledge can be gained by experts. Any new knowledge can be added to the Infinity Maps and the KG itself, thereby closing the loop. An overview of the entire pipeline is given in Fig. 1.

3 SHACL-based Transformation Framework

The Shapes Constraint Language (SHACL), is a W3C recommendation designed for validating RDF graphs against a set of SHACL shapes, i.e. the constraints the to-be-validated RDF graph has to adhere to. Such constraints can include (but are not limited to), e.g., checking existence of particular properties, data types, value ranges, and relationships between nodes⁵. Using SHACL, one can ensure that the data conforms to the expected structure and semantics, enabling reliable data integration and interoperability.

Additionally, we utilise SHACL Rules⁶ to facilitate the transformation of raw data (i.e., the Infinity Maps JSON exports) into a structured, and semantically enriched representation that aligns with predefined ontologies and the domain understanding as provided by the domain experts.

3.1 Handling Infinity Maps Data.

ex:FH9d47H93gf a dg:KPI, im:Node ;
    rdfs:label "Schließkraft Err" ;
    im:child ex:LnrDTfHTHqF ;
    im:id "FH9d47H93gf" ;
    im:parent ex:99dqJd2rjLb ;
    im:tag ex:Jj3qLGjGhGp ;
    im:title "Schließkraft Fehler" .

ex:LnrDTfHTHqF a im:Node ;
    rdfs:label "Abhängigkeiten" ;
    im:child ex:P2jBpjh8RjM, ex:Qbd7rnb ;
    im:id "LnrDTfHTHqF" ;
    im:parent ex:FH9d47H93gf ;
    im:title "Abhängigkeiten" .

ex:P2jBpjh8RjM a dg:Quantity, im:Node ;
    rdfs:label "Schließkraft Err (Gießen)" ;
    im:id "P2jBpjh8RjM" ;
    im:parent ex:LnrDTfHTHqF ;
    im:tag ex:BLJD8RqhTrd ;
    im:title "Schließkraft Err (Gießen)" .

As shown in Fig. 2, an Infinity Maps JSON export follows a very basic structure. At its core, each Infinity Map is represented as a JSON object with three main elements: nodes, edges, and tags. Where nodes represent all nodes in the Map, edges all edges between nodes, and tags are all tags used in the Map. As depicted in Listing lst:sample, each node has a unique identifier, a title, and optionally a reference to its parent node, and a list of references to any of its child nodes. Each edge has a source and target node, and a name. Each tag has a unique identifier and a title⁷.

3.2 Enrichment with Domain-Specific SHACL Rules.

Based on modeling guidelines specified by the process/domain experts, we define SHACL rules that capture the unique semantics and requirements of the domain. For example, one of the guidelines states that relations are represented by chaining at least two parent-child relationships between a starting entity and one or more target entities, where a relation contains exactly one node in its path that defines the type of the relation. The SHACL rule in Listing lst:prompt captures this by searching for paths starting from a set of focus nodes of type dg:Quantity, traversing through one or more im:child relationships to intermediate nodes ?p, and finally reaching target entities ?mid. Using the VALUES clause, we define the properties to be used based on the labels of the intermediate nodes. For example, for the example triples in Listing lst:sample, the following triple would be generated: ex:FH9d47H93gf dg:has_dependency ex:P2jBpjh8RjM .

enr:QuantityRule a sh:SPARQLRule ;
    sh:construct """
        CONSTRUCT {
            $this ?rel ?mid .
        } WHERE  {
            $this im:child ?typ .
            ?typ rdfs:label ?l ; im:child* ?p .
            ?p im:child ?mid .
            ?mid im:tag ?tag ; a ?target .
            VALUES (?l ?rel ?target) {
                ( "Abhängigkeiten" dg:has_dependency dg:Quantity)
                ( "Messung" dg:has_measurement dg:Signal)
            }
        }""" ;
    sh:condition [ # evaluate rule only if focus node is a dg:Quantity
        sh:property [
            sh:path rdf:type ;
            sh:hasValue dg:Quantity ;
        ] ;
    ] ; sh:prefixes <http://siemens.com/dgassist/enrichment> .

Conclusion and Future Work.

In this paper, we presented a novel approach that enables domain experts to model their knowledge using an easy and intuitive visual representation, which is then exported as JSON, and afterwards transformed into a semantically enriched KG representation using SHACL. Future work will focus on integration of additional SHACL rules as well as evaluation of the transformation process on different real-world use cases.