Learn the best way to develop a chatbot that gives answers based on data stored in a knowledge graph.

ChatGPT has modified how I, and doubtless most of you, take a look at AI and chatbots. We are able to use chatbots to assist us find information, construct creative works, and more.

Nevertheless, one problem with ChatGPT and similar chatbots is that they’ll hallucinate and return great-sounding — yet wildly inaccurate — results. The issue is that these large language models (LLM) are inherently black boxes, so it is tough to repair and retrain models to cut back hallucinations. Consequently, it may not be idea to rely on answers from ChatGPT if mission-critical tasks or lives are at stake.

Alternatively, there’s tremendous value in having the power to interact with chatbots and use them as an interface for various applications.

So I desired to learn more about chatbots, and fortunately Sixing Huang gave me a crash course on alternative ways of implementing a chatbot. I used to be especially intrigued by the knowledge graph-based approach to chatbots, where the chatbot returns answers based on information and facts stored within the knowledge graph.

Using a knowledge graph as a storage object for answers gives you explicit and complete control over the answers provided by the chatbot and means that you can avoid hallucinations. Moreover, Sixing has already written about and shared the code to implement a knowledge graph-based chatbot, which meant I could borrow some existing ideas and wouldn’t have to start out from scratch.

My idea was to develop a chatbot that may very well be used to explore, analyze, and understand news articles.

But first, I needed to construct a knowledge graph based on news articles. Luckily, I actually have used and written in regards to the information extraction pipeline quite a few times, so I didn’t need to lose time doing that. Next, it was time to implement my first chatbot. It turned out that making a knowledge graph-based chatbot is as easy as a walk within the park because of GPT-3. I constructed the next chatbot architecture.

The user talks to a Chatbot on a straightforward Streamlit application. When the user inputs their query, the query gets sent to the OpenAI GPT-3 endpoint with a request to show it right into a Cypher statement. The OpenAI endpoint returns a Cypher statement, which is then used to retrieve the data from the knowledge graph stored in Neo4j. The retrieved data from the knowledge graph is then used to construct the reply to the user’s query. Moreover, I actually have added the choice to summarize articles using the GPT-3 endpoint, which might be demonstrated later.

All of the code is obtainable on GitHub.

Constructing a knowledge graph

With a view to have the opportunity to retrieve information from the knowledge graph, we first need to populate it. As mentioned, the thought is to construct a knowledge graph of stories articles. Due to this fact, we want to search out a source of quality and accurate news articles. For the aim of this demonstration, I actually have used the newest 1000 articles available as a Kaggle repository. The articles can be found under the CC BY-NC 4.0 license.

We won’t be delving into details in regards to the information extraction pipeline, as I actually have already written about this subject repeatedly.

For essentially the most part, the thought behind the data extraction pipeline is to extract structured details about mentioned entities and relationships from unstructured text.

In this instance, the data extraction pipeline would discover entities and within the text. Moreover, most named entity recognition models can infer the entity type, meaning that it deduces whether the mentioned entity is an individual, organization, or other.

In the subsequent step, a relationship extraction model is used to detect any structured relationships between entities. The text within the above image clearly signifies the working relationship between and , which could be represented as an relationship.

Interestingly, we could use GPT-3 to extract structured information from text. A project GraphGPT provides a straightforward prompt that could be used to generate structured data based on an input text.

GPT-3 does a good job of extracting relevant information from the text. It also knows that within the second sentence references ,which is great. Nevertheless, it doesn’t recognize that and reference the identical real-world entity. Entity disambiguation is an important a part of any information extraction pipeline. One approach may very well be to make use of an entity-linking technique to map entities to a goal knowledge base. Often, Wikipedia is used as a goal knowledge base.

It’s improbable what we will achieve with a straightforward prompt using GPT-3 endpoint. Immediately, you’ll be able to notice that each and map to the identical Q145 id, which could be used for entity disambiguation. Alternatively, Boris Johnson is linked to Q1446 in each instances. All that might be great, nevertheless, the id Q1446 refers to a roman emperor .

While GPT-3 is great at following prompts, it tends to hallucinate external information like WikiData ids. While we would provide prompt for entity disambiguation in a single paragraph, it is tough to construct approach to disambiguate entities between various texts without entity linking.

We could develop our information extraction pipeline that deals with relation extraction and entity linking. I implemented such a pipeline two years ago. Nevertheless, since two years is rather a lot in the sphere of NLP, we would find an answer that gives higher accuracy.

To avoid developing a custom information pipeline, we’ll use a Diffbot NLP endpoint. The Diffbot NLP endpoint extracts relationships and provides entity linking out of the box. Moreover, it offers each paragraph and entity-level sentiments, which significantly expand the set of questions we will ask our chatbot, as we will ask it about positive or negative news regarding particular people or entities.

The code to run the data extraction pipeline using the Diffbot endpoint is obtainable as a Jupyter notebook. For this demonstration, you don’t have to run it, as I actually have stored the output of the data extraction pipeline within the project’s data folder. Nevertheless, if you must test it on other datasets and evaluate the way it performs, do give it a try.

Now that the brand new articles have been processed, we will import the output of the data extraction pipeline right into a graph database. In this instance, we might be using Neo4j. The GitHub repository is ready as much as run as two docker services, one for Neo4j and the opposite for the Streamlit application, so that you don’t need to install Neo4j on your individual.

You possibly can either run the seed_database.sh script or execute the Import notebook to populate the graph database with news articles. The graph schema of the populated knowledge graph in regards to the news is the next:

The knowledge graph comprises nodes containing information in regards to the article’s web title, body content or text, and sentiment. As well as, the articles can mention one or multiple nodes. The Entity nodes contain the URL property, which is the output of the entity-linking process, together with their id and sort.

Interestingly, the relationships between entities are usually not represented as connections in a graph but moderately as separate Relationship nodes. The concept behind this graph modeling decision is that we wish to trace the text where the extracted relationships originate from. As we all know, no NLP pipeline is ideal. Due to this fact it is crucial to have the power to confirm if a relationship is accurately extracted by manually examining the originating text. In a labeled property graph database like Neo4j, we cannot have a connection pointing to a different connection. Consequently, we model the extracted relationships between entities as an intermediate node.

Using a GPT-3 model to generate Cypher statements

We now have already learned that GPT-3 does an excellent job of following orders given in a prompt. Moreover, Sixing Huang has already written about how easy it’s to train the GPT-3 model to generate Cypher statements. The concept is to offer the model just a few examples after which let it generate a Cypher statement given the brand new user input. Specifically, I actually have prepared the next Cypher examples to coach the GPT-3 model.

Unfortunately, the GPT-3 endpoint has no concept of context, so we want to send the training examples together with every user input. I’m wondering what the ChatGPT API endpoint will seem like, as ChatGPT has an idea of the context of a dialogue and the way it’s going to affect end-user applications.

As shown on this image, every request to the GPT-3 endpoint starts with training examples. Interestingly, we don’t need to tell the model it should generate Cypher statements or anything — we just provide training examples together with a user prompt, and the model generates Cypher statements.

Chatbot implementation

Now that we’ve prepared all of the pieces of the puzzle, we will mix them in a chatbot application. I actually have used a Streamlit application — specifically streamlit-chat — to implement the user interface for the chatbot. I just like the Streamlit application because it keeps things easy, and I can use Python to develop the user interface while avoiding any meddling with CSS.

The applying uses the next Python code to generate the chatbot responses.

# Make a request to GPT-3 endpoint
completions = openai.Completion.create(
engine="text-davinci-003",
# Construct the prompt using the training examples
# combined with user input
prompt=examples + "n#" + prompt,
max_tokens=1000,
n=1,
stop=None,
temperature=0.5,
)
# Extract Cypher query from GPT-3 response
cypher_query = completions.selections[0].text
# Use the Cypher query to read the knowledge graph
message = read_query(cypher_query)
return message, cypher_query

As mentioned, all of the code is obtainable on GitHub if you happen to are considering more details. The repository also includes instructions to run the chatbot application.

Let’s now try the chatbot and see how well it behaves. We are able to start by utilizing an example from the training set of questions. The query is: “

The generated Cypher query is obtainable on the correct side of the chatbot user interface to permit for straightforward evaluation of generated Cypher statements. The query is within the training set, and due to this fact, the generated Cypher statement is similar to the instance we provided.

Next, we will try a variation of a matter that’s outside the training set. Nevertheless, similar examples are provided, and GPT-3 needs to mix information from two examples to generate the Cypher statement.

On condition that we provided only 11 training examples, I’m impressed with how well GPT-3 can generalize and construct appropriate Cypher statements. Alternatively, I’m quite pleased with how easy it’s to drill down the data provided in previous answers. It makes investigative work more fun and more accessible as you should use natural language to explore data as a substitute of getting to write down Cypher statements.

We are able to follow up and ask the chatbot in regards to the information we’ve stored about Emla Fitzsimons within the knowledge graph.

The chatbot provides information in regards to the extracted relationships which involve the actual person. In this instance, we all know that Emla is an worker of the Centre for Longitudinal studies, works with Marcos Vera-Hernandez, and is considering economics. This information was extracted using the Diffbot NLP endpoint and stored within the knowledge graph.

We are able to ask the chatbot if there are any more news about Emla.

It seems Emla is mentioned only in a single article. I assumed it will be cool so as to add an choice to summarize news articles using the GPT-3 endpoint. As GPT-3 model follows orders quite well, you simply have to ask it to summarize text, which does the job.

# Make a request to GPT-3 endpoint
completions = openai.Completion.create(
engine="text-davinci-003",
# Prefix the prompt with a request to supply a summary
prompt="Summarize the next article: n" + prompt,
max_tokens=256,
n=1,
stop=None,
temperature=0.5,
)
message = completions.selections[0].text
return message, None

I actually have added a straightforward exception within the code. If the user input comprises , then we assume the duty is to supply a summary of the given article.

For the reason that knowledge graph comprises each article and entity-level sentiment, we will seek for any entities with positive or negative sentiment. For instance, we will seek for organizations which have been mentioned positively within the news.

And just like before, we will ask the chatbot follow-up questions and drill down on the data we’re considering.

Summary

I desired to create a project that uses natural language to explore and analyze knowledge graphs for a very long time. Nevertheless, the barrier to entry was too high for me as I’m not a machine learning expert, and developing and training a custom model that generates Cypher statements based on user inputs was too big of a task for me.

And albeit, until I joined the ChatGPT hype, I wasn’t genuinely aware of how incredible the underlying technology is and the way well it really works. For instance, we only provided 10 training examples, and the chatbot behaves prefer it has worked with the given graph schema for the past five years.

Hopefully, this text will encourage you to implement your individual chatbots and use them to make knowledge graphs and other technologies more accessible!

The code is obtainable as a GitHub repository.