The need for digital libraries to store, catalogue, and manipulate documents is growing and the requirements are increasing daily. Much research is underway to discover efective ways to store and keep track of documents, their properties and uses. In this context, we propose the use of Labeled Property Graphs (LPGs) to store digital archives. The use of these graphs allows us high eficiency since the graphs are navigable very quickly thanks to Database Management Systems (DBMSs) (such as Neo4j) especially developed to guarantee high performance. On the other hand, this technology is not natively suited to infer new knowledge automatically. In this paper, we propose a method to use Semantic Web tools to enrich our knowledge base. This way, new operations are available, not possible with only graph databases. The proposed approach has been integrated into the GraphBRAIN (GB) system, a tool able to manage ontologies.
The Semantic Web (SW) is inspired by a vision of the current Web which has been in the
background since its inception, and which is influenced by earlier work dating back to Vannevar
Bush’s idea of the “memex” machine in the 1940s (based on a universal library, complete with
a searchable catalogue) [
From a more technical point of view, the design of software applications in general and for digital libraries, in particular, are strongly influenced by the persistence model used. The availability of reliable graph databases, therefore, opens new perspectives in the realization of applications. Graph databases allow importing diferent sources of data in a very flexible way due to the non-static nature of the data schemes. Graph databases were not created as a technology for the SW. In particular, the SW is based on the RDF model diferent from the Property Graph model of graph databases.
In this paper, we propose an approach for knowledge enrichment in a graph database. To do so, it will be necessary to map the LPG data in RDF and make use of Ontology Web Language (OWL) ontologies.
In the next sections, we will see in detail how we realized the proposed approach inside the GraphBRAIN tool and which functionalities can be realized through the use of an SW reasoner.
This paper is organized as follows: Section 2 treats the state-of-art of. Section 3 describes the building blocks of our proposal, particularly focusing on the proposed ontology for Library domains, the translation mechanisms and the reasoning. Section 4 summarizes and concludes the proposal.
Even if not strictly applied to digital libraries, in the literature, we found several attempts to
integrate, and, possibly, extract new knowledge or create a mapping between graph databases
and the SW. Many of them, however, did not consider the idea of putting them together for
exploiting the advantages of both.
neosemantics 1 is a Neo4J plugin that enables the use of RDF and its associated vocabularies
like (OWL, RDFS, SKOS and others) in Neo4j. At the current stage neosemantics ofers an
1Neo4j neosemantics library, https://neo4j.com/labs/neosemantics
import/export mapping starting from an RDF graph, but starting from an LPG graph the mapping
of all contained information is not guaranteed. On the other side, native RDF repositories,
like GraphDB 2, are conceived to store RDF model rather than LPG. We aim to exploit the
characteristics of the property graph by using its available functionalities and enabling SW tools
to enrich the knowledge in the LPG. In [
For the first implementation of our proposal, we leveraged several previous works and
systems from our past research. The entire architecture we will describe has not yet been fully
implemented, in this work we propose a general solution. Our initial prototype was integrating
and combining them for carrying out the many activities required. Knowledge storage and
management was carried out using GraphBRAIN [
Since ontology and knowledge graph management is the core of our proposal, we will describe in some more detail the GraphBRAIN component. It provides a tool to design and collaboratively populate knowledge graphs, and advanced solutions for their fruition, consultation and analysis. A distinguishing feature of GraphBRAIN is its mixing Knowledge Representation and Graph Database technologies to take advantage of both, the eficiency (scalability, storage optimization, etc.) of the latter and the flexibility and power of the former for storing and handling knowledge. The graph DBMS implementing the knowledge base is Neo4j4. While it is schema-free (the user may apply any label and/or attribute to any single node or arc), GraphBRAIN imposes the use of a predefined XML data schema (GB schema). It represents a form of ontology schema, so that only data that are compliant with it may be added to the graph, and all functions are driven by it. The GB schema defines what (kinds of) knowledge can be represented in the knowledge base, how it is to be described, and how it can be exploited. While maintaining a single, overall graph to store the data, GraphBRAIN is designed to allow the use of diferent GB schemes on it, each expressing a diferent domain or perspective. So, using a specific GB scheme one has only a partial view of the knowledge. However, diferent GB schemes may share the same classes (uniquely determined by name, so that alignment is easily obtained), possibly defining diferent sets of attributes for them. E.g., classes such as Person, Place, or Document are expected to appear in diferent domains/schemes; in one schema an attribute of Person might be its professional title, which is not needed in others. Individuals of shared classes act as bridges, allowing the computations in a domain to reach and exploit information coming from other domains. This implies that adding new items under one domain will automatically enrich also the other domains whose instances can be reached via some path in the graph. To the best of our knowledge, this is a completely innovative setting, that enables cross-fertilization among, and knowledge reuse across, diferent domains. It is fundamental to enforce our ‘contextual’ perspective. Furthermore, GraphBRAIN can import/export its ontologies and knowledge graphs from/to Semantic Web languages, e.g., OWL and RDF.
In general, the functions provided by GraphBRAIN bring to cooperation many diferent Artificial Intelligence tasks, techniques and approaches for improving knowledge management and (personalized) fruition by users, including database technology, data mining, machine learning, natural language processing, recommendation, collaborative and social interaction tools, social network analysis. This allows it to find relevant, personalized and non-trivial information. E.g., a social approach can be used to build and integrate GB ontology schemes and user models can be used to guide data mining.
This is useful for some functionalities based on the statistic field outside of the SW technologies application but is required and useful. In particular, the Link Prediction algorithms works on pieces of graph allowing to display the nodes and arcs. Over these nodes and arcs the following algorithms can be executed: Adamic-Adar Index, Common Neighbor, Resource Allocation Index and Katz.
Here we show the proposed GB schema. It is not strictly related to SW ontology but is LPG oriented since it contains some restrictions needed to the application level. Furthermore, GB scheme could be extended to represent semantic information with languages diferent from those ofered by SW, like Inductive Logic Programming or datalog. For the GB schema definitions, we refer to our previous work, which will certainly be extended and deepened [14]. From the semantic abstraction layer, we refer to a GB schema and a related use case 4Neo4j Graph Data Platform - www.neo4j.com within GraphBRAIN. Here we will give an overview of its artefact based on the meaning rather than a formal representation, trying to explain the underline semantics. It includes several general concepts relevant to the library domain, among which User (whose identity may be unknown), Person (whose identity is known, possibly associated to a user), Author (who is a person who writes something) and Place (a place in which something happens). These concepts can be considered general, widely used concepts and reusable in most domains. Then, there are the domain-specific concepts for the library. Among the most obvious, Document (to describe a piece of knowledge), Book (a particular case of Document), Stream (stream of data), Multimedia (e.g., images, audios and videos), Award (for prizes and recognitions) and many other minors. The GB ontology schema must be able to describe the contents of sources since they are the main elements for which this ontology is meant to be used. Documents may take many very diferent forms, requiring a more elaborate structure for this concept. The most prominent kinds of documents are books, papers, articles, blogs, websites, posts and many other possible sub-concepts at diferent levels. Multimedia objects should be distinguished as well (Music, Image, Audio and Video). For fine-grained handling of documents, we also provides concepts to describe their layout (Page, Table, ...) and logical (Title, Section, ...) structure, their text and its grammatical structure (Sentence, Subject, Object, ...), and the concepts (Category) and Named Entities (Person, Place, etc.) they mention. Some other concepts can be used for auxiliary purposes like Artifact (including artisanship and industrial items, or works of art, such as statues and paintings), Device (including simple tools, such as hammers, and more complex systems, such as computers), Software (again, with a taxonomy of sub-concepts for the diferent kinds of software) and IntellectualWork (including tools, algorithms, programming languages, technologies, theoretical models and so on). We provide many relationships to connect instances of these concepts. Some are needed to organize documents into layout and logical components (e.g., has links a Document to its layout and logical components; partOf structures components into sub-components, etc.) and to associate their content with generic concepts or specific named entities (mentions). LayoutComponents also have a spatial organization, expressed by relationships leftOf and above. Authors and documents are connected to them through the developed relationship. Other relationships can be easily figured out by readers (e.g., those linking Persons to Organizations, or those describing the syntactic and semantic structure of the text. As an example, we take the Document concept having the following attributes among the others (see Figure 2): name, ISBN, firstAuthor. There are a lot of other attributes but we refer to these three just for the example we mean to explain.
To apply the SW reasoning, as the first step we need to generate an OWL ontology from GB schema. With this aim, we have designed a mapping between their entities reported in Table 1. The main step to bring concepts and relationships into the SW is to assign them a unique URI. For our scopes, we use the following namespace: “https://gbnamespace#” whose given abbreviation is dl. Hence, every concept and relationship described in the previous section will contain that namespace when translated into OWL definitions. GraphBRAIN is also able to import OWL ontologies. In this case, the mapping in the Table 1 is applied from OWL to XML. This procedure is limited to the entities that are representable in GB schema. The OWL classes and datatype properties of the example are, for a matter of size, shown in part below. <?xml version = " 1 . 0 " ?> < !DOCTYPE r d f : R D F [ <!ENTITY d l " h t t p : / /www. g r a p h b r a i n . i t # " >
< ! ENTITY owl " h t t p : / /www. w3 . org / 2 0 0 2 / 0 7 / owl # " > < ! ENTITY xsd " h t t p : / /www. w3 . org / 2 0 0 1 / XMLSchema# " >
RDF Element rdf:subject rdf:predicate rdf:predicate between the rdf:subject (node) and the literal
(Attribute value) rdf:predicate between the rdf:statement representing the triple (relationship) and the literal (Attribute value) Complementary to the ontology in OWL, we need data in the form of RDF triples, with the subject-predicate-object structure. There are several techniques to achieve this. We decided to exploit the potential of Neo4j that allows us, through a Cypher query, to extract data from a db in JavaSript Object Notation (JSON) format using the Neo4j APOC library5. In this way, we can parse the JSON file and render all the extracted nodes and arcs (with their respective attributes) into RDF. To do this, we follow the mapping rules listed in Table 2. We can render in RDF the whole LPG or pieces of a graph. By extracting a part of the graph related to what has been required to render, we can prepare to respond more quickly to the next requests that presumably will be made from the requester (for example from an SW reasoner). We can take new instances from LPG with diferent techniques. For example, all nodes and arcs far k hops from a central node.
We do not keep a copy of the database as RDF triples, RDF triples are generated on the fly from a request by a requester. Referring to our example, suppose we obtain from the graph the following node rendered in RDF where the information about the first author is missing: < r d f : R D F x m l n s : r d f = " h t t p : / /www. w3 . o r g / 1 9 9 9 / 0 2 / 2 2 − r d f − s y n t a x − n s " x m l n s : d l = " h t t p s : / / g b n a m e s p a c e \ # " > < r d f : D e s c r i p t i o n r d f : a b o u t = " h t t p s : / / g b n a m e s p a c e / DivineComedy " > < d l : i d > 6 0 5 6 < / d l : i d > < d l : i s b n > 9 7 8 − 8 1 − 7 5 2 5 − 7 6 6 − 5 < / d l : i s b n > < d l : n a m e > D i v i n e Comedy< / d l : n a m e > < / r d f : D e s c r i p t i o n > < / r d f : R D F >
5Export Neo4J graph to JSON, https://neo4j.com/labs/apoc/4.1/export/json
After extracting some nodes and reading the ontology, one of the available SW reasoners can be used. The operations possible with SW reasoners mainly concern hierarchies among classes or instance checking. The most useful operation can be to check the consistency of the knowledge base during the input of data in the LPG using GraphBRAIN.
Furthermore, having the possibility of reading other OWL ontologies and related RDF triples, we can merge information not contained in our graph database.
In this first proposal, we map the external OWL ontology classes with GB ontology schema applying a (sub)string matching and imposed owl:samAs properties when a match is found. In this way, LPG instances will be rendered as owl:individuals or the mapped OWL ontology. Remind that this is just a first proposal of the architecture and, since we have not developed the system in its totality, we can further investigate advanced techniques for this relevant aspect of this architecture. Turning back to our example, suppose to import (among the many sources) an OWL ontology (whose abbreviated namespace is "odl") that states in its RDF store that the Author of Divine Comedy is "Dante Alighieri". The alignment procedure has found a correspondence between the attributes odl:Author and dl:FirstAuthor. Since FirstAuthor is not a mandatory field, we have no author given for the Book "Divine Comedy" in the LPG. Applying the reasoner, this information is suggested to the GraphBRAIN administrator that can evaluate if adding it to the LPG. This is just a trivial example, reported completely in Figure 3 but it is easy to imagine, in the same context, if we have two diferent information coming from diferent sources. These types of situations are very common when handling digital libraries where large communities can put data and metadata in the graph with limited control from GraphBRAIN. The extracted information is not stored anywhere if the administrator decides to not insert them in the database. In this way, we are sure to avoid unwanted or unpredictable changes to our source.
In this paper, we have proposed a system that can efectively combine graph databases and the SW to deduct new knowledge which is something not possible only with Neo4j. We proposed to manage an LPG in Digital Library Domain with GraphBRAIN to have some level of control on the contained information. An approach implemented in GraphBRAIN for the generation/import of OWL ontologies and a mapping between LPG data and RDF formalism is given. Many improvements can be applied and we are working to integrate them. Indeed, this work lends itself well to numerous extensions. First, there are several ways through which significant nodes of a graph can be extracted. In the GraphBRAIN system, some algorithms are already available for visualizing parts of the graph, like Katz Centrality and PageRank Centrality. There is a further possibility of using the SW reasoner to infer new knowledge. [13] S. Ferilli, Integration strategy and tool between formal ontology and graph database technology, Electronics 10 (2021). [14] S. Ferilli, D. Redavid, An ontology and knowledge graph infrastructure for digital library knowledge representation, in: Digital Libraries: The Era of Big Data and Data Science, volume 1177 of Communications in Computer and Information Science (CCIS), Springer International Publishing, 2020, pp. 47–61.