5 Reasons Knowledge Graph will never bloom
Authors: Dr Dongsheng Wang and Dr Hongyin Zhu
Figure 1. Knowledge Graph Visualization Example (From Web)
Knowledge Graph (KG) is used to organize knowledge as a graph with nodes and edges (called triples). KG has been one of the most popular technologies in the AI community and has attracted increasing attention in recent years. However, KG is definitely not a new technology, by analyzing its past and present, this article will detail five persistent reasons why KG will never thrive (or at least in the next two decades).
Since its proposal in 1989, the key technology behind the Semantic Web has remained largely unchanged, despite its various iterations, including semantic technology, knowledge base, linked data, and the current so called Knowledge Graph (KG). In other words, despite over two decades of effort with all those different versions, none have managed to thrive as expected. While the latest version — KG has set a smaller goal, the question remains as to whether it will be successful in the coming decades. To answer this, it’s important to review its development from inception to present day, as it is critical to examine the factors that have so far prevented KG from reaching its original goals.
We begin by revisiting the challenges that undermined the Semantic Web’s original ambition to revolutionize the web. We then turn to its more modest successor, the Knowledge Graph (KG), whose primary aim is simply to organize knowledge. We identify five key challenges: (1) difficulties in entity generalization, including issues of granularity and ambiguity; (2) relation overloading; (3) the complexity paradox arising from simple triple-based representations; (4) limited accessibility; and (5) latency in knowledge acquisition.
Arguably, its own development has been largely stagnant for decades. Knowledge Graphs (KGs) have instead borrowed heavily from connectionist methods over the past ten years — from word embeddings and neural networks to deep learning models such as Transformers and BERT. In other words, their major advances have been driven more by progress in connectionism than by symbolic approaches themselves. Even so, representation learning is unlikely to resolve the core limitations of KGs and may actually even exacerbate them.
At the end, we offer minor practical recommendations grounded in our R&D experience. We believe that substantive, and even radical, changes are required to overcome the stagnation that has constrained the development of KGs and their predecessors. Only through bold and innovative departures from past approaches can the KG move toward a truly meaningful future.
1 Origin of Knowledge Graph — Semantic Web
1.1 Grand proposal for Web3.0
The original vision for the Web was to progress from Web 2.0 to Web 3.0, marking a new era of development. This can be understood as a chronological evolution of three different phases: Web 1.0, Web 2.0, and the targeted Web 3.0.
Web 1.0 was a unidirectional service model where a few editors maintained servers to serve a large number of users, for example, Yahoo and Sohu. Web 2.0, on the other hand, was a bidirectional service model with no clear boundaries between users and editors, exemplified by social networks, blogs, tweets, YouTube, Instagram, and so on. As a result of this design, editors became users themselves, leading to a significant increase in data. Web 3.0, or the Semantic Web, involves the use of machines as the third component in the triangle relationship between machines, users, and editors, and is characterized by machine-readability and machine-understandability.
1.2 One word to understand semantic web — Unifying
It has ever been a myth for a long time when the semantic web was first proposed two decades ago because it is often related to the terms of machine-readable, semantics, reasoning, or whatever fancy terms you might have seen somewhere. However, the core principle of the semantic web can be distilled into a single word: “unifying.” The goal of the semantic web is simply to unify data in a comprehensive manner, with the RDF triple format serving as a universal solution for global knowledge representation. In the following sections, we will explore how the various complex concepts associated with the semantic web can be understood as the single word — ‘unifying’:
- Unifying = formalized、standardized data
- Unifying = could be distributed (because of the same triple format)
- Unifying = Machine-readable (by designing a resolver to this unified format)
- Unifying = re-use & share (again, same data format)
Therefore, if someone mentions terms like “standardized, formalized, semantics, machine-readable, reasoning,” or other related terms, you can simply say “Ah, I understand, you’re referring to unifying.”
The unified form of RDF is simply a composition of triples, with each string adopting a URI for uniqueness. The triple format, consisting of subject, predicate, and object, is considered the minimum unit necessary to describe world knowledge. This is why a relational database can always be represented as RDF data, as illustrated in the example below. The philosophy behind the triple format is that a 2-tuple is insufficient, and a 4-tuple can always be reduced to a triple.
Figure 2. A 5-tuple or relational database to RDF triples
The SW community has long been focused on generating ontologies, which involves transforming existing web data into RDF format.
However, machine-readability is only possible when there is a parser capable of recognizing the unified RDF format. It’s important to note that no data format inherently possesses reasoning capability. In the case of natural language, humans serve as parsers because we have learned languages like English, Chinese, and Korean. Similarly, programming languages such as Jena and query standards like SPARQL have been developed as parsers for the unified RDF format, enabling machines to understand and interpret the data.
1.3 Four reasons why SW has faded
It has been over two decades since the concept of the Semantic Web was first introduced, yet it has not evolved into the anticipated influential Web3.0 era. Why has this been the case? We can identify four main barriers that have hindered the development of the Semantic Web.
1.3.1 RDF Sharing disability
Academic agents have been mainly focused on building their knowledge bases, which are intended to be global datasets. However, these RDF databases often suffer from being hard to understand, outdated, unreliable, and substantially diverse, making it challenging to achieve reliable linked data. As a result, they tend to become another type of local databases.
On the other hand, industrial companies are more realistic and pragmatic, and there is currently no strong incentive for them to widely and effectively transform or share their data as RDF. Many companies display data on the internet in JSON format, which is often sufficient for developers. Even if some private companies and industries are willing to share their data, they may not want to make the additional effort to publish RDF data since it requires more effort than reward.
1.3.2 Expensive to consume RDF
Consuming RDF data requires a significant effort. From an engineering perspective, applications typically interact with local data or data from specific APIs transmitted in JSON format. JSON data is structured, accessible, and sufficient for describing entities. When working with RDF data, it is necessary to first study its schema and parse it into local memory to assemble triples into complete instances. This process is necessary because triples of the same entity can be distributed, and predicates can be arbitrary.
Without adopting external RDFs effectively, a local RDF database is not superior to a simple relational database. Therefore, people are still more willing to write programs that parse structured JSON than to learn RDF schema and ensemble triples in memory. Overall, manipulating RDF data is often trivial, time-consuming, and expensive, which outweighs its potential benefits.
1.3.3 Ontology definition splurging
The ideal scenario for RDF datasets is that everyone uses shared word schemes to define them, which means unifying ontology schemes as much as possible.
However, the reality is that scheme splurging is usually exponential, resulting from different groups of people from different places. As a result, understanding a new RDF dataset from an unknown source can take a significant amount of time. Despite having Linked Open Vocabulary (LOV) available for years, unifying schemes is still a challenge. It seems unlikely that there will be a breakthrough in this field in the near future, even with similar efforts spanning decades.
Figure 3. LOV(2018)
1.3.4 Expensive to use first-order logic
The focus on reasoning capacity by early Semantic Web researchers created high expectations but ultimately led to disappointment. Despite advances in reasoning techniques, including path reasoning using machine learning, inference accuracy remains unsatisfactory and unreliable. Three main reasons contribute to the failure of this approach.
First, first-order logics have not been widely adopted in traditional AI systems, and their reasoning efficiency and effectiveness are questionable.
Second, descriptive logics require high-quality and small-scale data, making it infeasible to scale up to the large amounts of dirty data generated daily.
Finally, alternative methodologies such as machine learning models trained on massive datasets can be more effective and efficient than descriptive logics. As a result, first-order logics are expensive and replaceable.
2 Five reasons KG will not be thriving
Although the Semantic Web has faded into obscurity, its successor — Knowledge Graphs (KG) — has been reintroduced as a semantic representation framework for NLP and Information Retrieval. KG focuses on organizing information with entities and their relations, which is a smaller target than revolutionizing the entire web. Some researchers are highly optimistic about KG because they have adopted knowledge representation learning to improve its effectiveness. However, we believe that KG will not lead to any breakthrough because the same problems that have plagued the Semantic Web for two decades are still present. Furthermore, attempting to solve these problems with KG may only exacerbate them. It is as if a child who cannot crawl is attempting to run, and we will elaborate on this further from the perspective of KG.
2.1 Challenges in Generalizing Entities: Granularity and Ambiguity
Two major challenges in generalizing entities are granularity and ambiguity. The first challenge is that entities often lack clear boundaries — for example, the distinction between ‘Mouse Brain’ and ‘Brain’, or between ‘Apple’ and ‘Green Apple’. Such entities may exist independently in different contexts, while in others one may contain the other. Determining the right granularity is therefore highly context-dependent and must be adapted to specific domains or use cases, making standardization for general-purpose KG difficult.
Ambiguity is another well-known difficulty in entity definition. For instance, ‘Green Apple’ can refer to a fruit, a music album, a book title, a brand, or even a chapter in a document. Although it is possible to create a distinct entity for each meaning, doing so at scale would make the knowledge graph overly complex and difficult to maintain, while often adding little practical value.
However, these approaches do not resolve the core problems of entity granularity and ambiguity. For example, a simple query like “Who is Obama?” may still return multiple candidates — politicians, athletes, singers, and other public figures — leaving the user or the system to perform further disambiguation.
This helps explain why, despite extensive academic research on KG embeddings, they have seen little uptake in production systems: their accuracy in complex real-world settings remains uncertain.
Figure 4. knowledge graph embeddings (from web)
To summarize, the problems of entity granularity and ambiguity remain unresolved in knowledge representation, including the Semantic Web and knowledge graphs. These issues were not solved by earlier research on Semantic Web technologies such as ontology definition and alignment. Moreover, when multiple knowledge graphs are involved, the ambiguity problem becomes even more complex. In other words, the field has been trying to define, align and disambiguate entities for over twenty years — and the effort is still ongoing.
2.2 Relation splurging and explosion
Looking at Figure 1, it appears easy to read because the relations mostly consist of multi-word phrases. However, these relations can become exponentially complex, derived from the simple triple format. To express the natural relations between entities, the knowledge graph often uses compound phrases. However, facing hundreds of relations like song_of, written_by, create_by, is_author_of, build_time, cause_by, has_been_to, and has_visited, humans can become confused by the ambiguity, let alone machines. This is why it is sometimes necessary to define the domain and range if you expect certain relations to belong to specific classes. Consumers must first understand the concept and relation definition of the KG. However, as relations grow from different sources, they become increasingly ambiguous with one another, such as belongs_to, part_of, and included_by. Therefore, it is difficult to disambiguate by either humans or machines.
Researchers have been heavily focusing on knowledge representation learning in recent years, often combining it with knowledge graph embedding and deep neural models applied to NLP corpora. By projecting entities and relations into low-dimensional space (embedding space), they aim to improve knowledge graph completion, entity recognition, relation extraction, and other KG-related tasks. Pre-trained models like BERT have been particularly successful in enhancing performance in these areas. However, the massive amount of learned entities and/or relations can lead to diverse granularity and complexity, ultimately exacerbating the problem of ambiguity. Furthermore, managing new triples in a KG is already a challenging task, and when dealing with heterogeneous KGs, the issue of relation splurging can quickly spiral into relation explosion, making it extremely difficult to consume. In essence, the current obsession with knowledge representation learning is like a child attempting to fly before learning to walk.
2.3 The Complexity Paradox of Simple Triple Representation
The triple format has simplified the data sharing as a minimum unit to represent world knowledge. However, the KG creator, in turn, has to define complex relations with the compound phrase for accurate description as discussed in section 2.2.
The triple knowledge form eventually brings even more complex than we imagined. When we ask who the United States president is, we can retrieve the triple: (X, president, United States). This actually hides a default that we are asking the current president. When the question is slightly different, like “who was the United States president in 1989?”, we have to use a query like (X, is_the_40th president, United States) or (XX, president_period, from 1981 to 1989). This quesion immediately increases the complexity of retrieving, and actually, this triple knowledge itself is an ambiguity for the previous simple question as you can imagine. In reality, it is more common to have knowledge containing constraints that involve multiple relations rather than single relation. As shown in the Figure 5 below, this is more than trivial for both who design it or who consume it.
Figure 5. from web
We should not blame that developers sometimes question would it be more straightforward if we can design a relational database table. When you employ a relational database with a table name called ‘president’, you can easily define the properties that belong only to this table like name, x_th, period, spouse, spouse_period, etc. And this concept oriented design, in general, is more accessible and human-understandable than RDF oriented design.
Having confused human ourselves, knowledge with multiple relations are also ambiguous to machines. We can find that even with state-of-the-art knowledge representation learning models, the F1 performance is generally lower than 50% for complex question answering over KG. This is almost meaningless for industrial application. When there are errors in the KG, the correction process is usually much more tedious than a relational database.
In short, knowledge is often diverse and conditional than simple deterministic knowledge. When we use simplified triple formats to express complex knowledge, we end up with higher complexity.
2.4 Hard to access Knowledge Graph as a database
The consumption of triple knowledge requires a high understanding of the ontology schemes and RDF query knowledge for whoever wants to access it. People inevitably have to parse and load all the triples together in memory and manipulate it with a program (like Jena library), SPARQL query, or sometimes both. The reason is that these triples can be located in different lines or different files and databases. We know this mechanism is the advantage of the triple format that enables distributed storage but it sets the barrier for us to look it up quickly on the other side.
Moreover, the triples are usually not readable due to URIs and distributed triples. What we see first are usually the triples like (<uri:28809> <uri:creator> <uri:201339>), then we have to figure out the readable relations like ‘rdfs:label’, ‘skos:prefLabel’ or ‘dbpedia:name’, in order to find triples like (<uri:28809> <rdfs:label> “The Matrix”). This process always force the consumers to spend quite a bit time to figure it out what relations an entity might have. In addition, the SPARQL queries are more complicated than SQL because of the diverse URIs and complex query grammar.
In short, the URI mechanism and SPARQL have been barriers that stopped many developers from accessing, plus the relation splurging lead to more complexity than the convenience they brought for KG consumption.
2.5 Unreliable quality and generation latency
The constructed RDF usually suffers from quality and latency problem. First, there is no technology so far that can guarantee the accuracy of RDF triples.
Even if the triples are accurate, triple knowledge acquisition is always slower than the emerging of new data. In other words, RDF generation is a linear effort of us, while the speed of new information growing is exponential. For example, when Elon Must tweeted a message, it will be commented on and retweeted tens of thousands of times within a few minutes. This is why the end-to-end deep learning models are more and more popular because it avoids extracting the information as structured data but directly consumes the raw data to predict the ultimate purpose.
In short, we do not want a structured dataset that is not reliable and is of high latency in general.
3 Why people still insist it
In this article, we have provided a comprehensive review of the development of KG, from its origin in the semantic web to its current purpose. Despite this, the main problems we have discussed remain unsolved or even exacerbated. We have argued that knowledge representation learning is unlikely to mitigate these problems; in fact, it may worsen them. For instance, the fact that even with state-of-the-art models, performance on complex question answering is still below 0.5 (F1) suggests that optimism about KG’s potential should be tempered. Given that many researchers may be aware of these issues, it is unclear why some continue to be obsessed with KG, and why some top researchers claim it could lead us to ‘cognitive intelligence’ or ‘advanced intelligence’.
We attempt to clarify our stance with the following four points:
- KG is currently the most promising technology that shares similarities with human thinking.
- There are no other alternative technologies that can sustain hope for the next breakthrough, especially after the advancements of deep learning from the connectionism community.
- We acknowledge that there is a compromise between symbolism researchers and connectionism researchers.
- Technology media often prioritize propaganda over accountability, and researchers may not face consequences for making grandiose claims.
4 Our Suggestions
While we do not have all the answers, we share the same hope as you that a new design can be proposed to replace KG, although this may be a difficult task. Our intention in this article is to highlight potential directions that could address some of the problems we have discussed.
4.1 Emphasizing knowledge rather than the form or graph
There is a need to shift the focus from the form of knowledge, such as natural language or RDF, to the knowledge itself. Natural language understanding and generation have advanced significantly, but there is still much to be done to make KGs compatible with these advancements. Recent research suggests that pre-trained language models may already contain relational knowledge, although this view is not universally accepted. Moreover, it is often not visible or consumable in a straightforward way. While the general KG may not be a viable solution, token-level semantics from models like BERT can be used to construct domain-specific entities for specific use cases.
Technically, there is a need to strike a balance between the simplicity of triple formats and the information richness of n-tuple structures in representing knowledge. While technologies like Neo4j are moving in this direction, there is a need for a new standard that involves researchers and developers in defining a schema and n-tuple knowledge that can be easily understood and accessed by both humans and machines. This will enable a more efficient and effective use of knowledge graphs in various applications.
4.2 Ease the KG technology as much as possible
While URIs are often considered essential for global uniqueness, cheaper alternatives exist. Universally unique identifiers (UUIDs) can identify entities both locally and globally, ensuring uniqueness even when merging datasets. Therefore, UUIDs can effectively replace URIs for entities and predicates with minimal impact.
If we create an n-tuple knowledge form, we should ensure that the knowledge pieces are easily accessible through both manual check-up and query languages like SPARQL (though a more lightweight version would be preferable). To enhance the usability of the n-tuple knowledge form, confidence and label should be two of the mandatory relations for each knowledge piece.
Final words
Finally, it is important to note that our intention is not to dismiss the value of knowledge graphs altogether. Rather, we are highlighting the potential limitations and challenges that may arise as the complexity and ambiguity of KGs continue to grow. We believe that it is important to approach the development of KGs with realistic expectations and a clear understanding of the potential trade-offs involved. This article represents our perspectives and is intended for reference purposes only. We welcome any comments, criticisms, or alternative viewpoints on this topic.
Authors introduction:
The two authors, Dongsheng Wang and Hongyin Zhu, have extensive research and development experience spanning seven years in the fields of Knowledge Graphs and Natural Language Processing (NLP). Dongsheng Wang earned his PhD from the University of Copenhagen, while Hongyin Zhu received his PhD from the University of Chinese Academy of Sciences. Currently, Dongsheng Wang is working in industry on Conversational AI, while Hongyin Zhu is a postdoctoral researcher at Tsinghua University, working on Knowledge Graphs. If you wish to contact them, you can reach out to Dongsheng Wang at dswang2011@gmail.com and Hongyin Zhu at hongyin_zhu@163.com.
