Tutorial: Question Answering on a Knowledge Graph


Open in Colab Download
Last Updated: July 5, 2023

Starting from version 1.15, BaseKnowledgeGraph, GraphDBKnowledgeGraph, InMemoryKnowledgeGraph, and Text2SparqlRetriever are being deprecated and will be removed from Haystack as of version 1.17. For more details about this deprecation, check out our announcement on Github.

Haystack allows storing and querying knowledge graphs with the help of pre-trained models that translate text queries to SPARQL queries. This tutorial demonstrates how to load an existing knowledge graph into haystack, load a pre-trained retriever, and execute text queries on the knowledge graph. The training of models that translate text queries into SPARQL queries is currently not supported.

To start, install the latest release of Haystack with pip:

Preparing the Colab Environment

Installing Haystack

To start, let’s install the latest release of Haystack with pip:

%%bash

pip install --upgrade pip
pip install farm-haystack[colab,inmemorygraph]==1.16.1

Enabling Telemetry

Knowing you’re using this tutorial helps us decide where to invest our efforts to build a better product but you can always opt out by commenting the following line. See Telemetry for more details.

from haystack.telemetry import tutorial_running

tutorial_running(10)

Logging

We configure how logging messages should be displayed and which log level should be used before importing Haystack. Example log message: INFO - haystack.utils.preprocessing - Converting data/tutorial1/218_Olenna_Tyrell.txt Default log level in basicConfig is WARNING so the explicit parameter is not necessary but can be changed easily:

import logging

logging.basicConfig(format="%(levelname)s - %(name)s -  %(message)s", level=logging.WARNING)
logging.getLogger("haystack").setLevel(logging.INFO)

Downloading Knowledge Graph and Model

from haystack.utils import fetch_archive_from_http


# Let's first fetch some triples that we want to store in our knowledge graph
# Here: exemplary triples from the wizarding world
graph_dir = "data/tutorial10"
s3_url = "https://fandom-qa.s3-eu-west-1.amazonaws.com/triples_and_config.zip"
fetch_archive_from_http(url=s3_url, output_dir=graph_dir)

# Fetch a pre-trained BART model that translates text queries to SPARQL queries
model_dir = "../saved_models/tutorial10_knowledge_graph/"
s3_url = "https://fandom-qa.s3-eu-west-1.amazonaws.com/saved_models/hp_v3.4.zip"
fetch_archive_from_http(url=s3_url, output_dir=model_dir)

Initialize a knowledge graph and load data

Currently, Haystack supports two alternative implementations for knowledge graphs:

  • simple InMemoryKnowledgeGraph (based on RDFLib in-memory store)
  • GraphDBKnowledgeGraph, which runs on GraphDB.

InMemoryKnowledgeGraph

from pathlib import Path

from haystack.document_stores import InMemoryKnowledgeGraph


# Initialize a in memory knowledge graph and use "tutorial_10_index" as the name of the index
kg = InMemoryKnowledgeGraph(index="tutorial_10_index")

# Delete the index as it might have been already created in previous runs
kg.delete_index()

# Create the index
kg.create_index()

# Import triples of subject, predicate, and object statements from a ttl file
kg.import_from_ttl_file(index="tutorial_10_index", path=Path(graph_dir) / "triples.ttl")
print(f"The last triple stored in the knowledge graph is: {kg.get_all_triples()[-1]}")
print(f"There are {len(kg.get_all_triples())} triples stored in the knowledge graph.")

GraphDBKnowledgeGraph (alternative)

Launching a GraphDB instance

Unfortunately, there seems to be no good way to run GraphDB in colab environments. In your local environment, you could start a GraphDB server with docker, feel free to check GraphDB’s website for the free version https://www.ontotext.com/products/graphdb/graphdb-free/

# import os
# import subprocess
# import time

# LAUNCH_GRAPHDB = os.environ.get("LAUNCH_GRAPHDB", False)

# if LAUNCH_GRAPHDB:
#     print("Starting GraphDB ...")
#     status = subprocess.run(
#         [
#             "docker run -d -p 7200:7200 --name graphdb-instance-tutorial docker-registry.ontotext.com/graphdb-free:9.4.1-adoptopenjdk11"
#         ],
#         shell=True,
#     )
#     if status.returncode:
#         raise Exception(
#             "Failed to launch GraphDB. Maybe it is already running or you already have a container with that name that you could start?"
#         )
#     time.sleep(5)

Creating a new GraphDB repository (also known as index in haystack’s document stores)

# from haystack.document_stores import GraphDBKnowledgeGraph

# # Initialize a knowledge graph connected to GraphDB and use "tutorial_10_index" as the name of the index
# kg = GraphDBKnowledgeGraph(index="tutorial_10_index")

# # Delete the index as it might have been already created in previous runs
# kg.delete_index()

# # Create the index based on a configuration file
# kg.create_index(config_path=Path(graph_dir) / "repo-config.ttl")

# # Import triples of subject, predicate, and object statements from a ttl file
# kg.import_from_ttl_file(index="tutorial_10_index", path=Path(graph_dir) / "triples.ttl")
# print(f"The last triple stored in the knowledge graph is: {kg.get_all_triples()[-1]}")
# print(f"There are {len(kg.get_all_triples())} triples stored in the knowledge graph.")

# # Define prefixes for names of resources so that we can use shorter resource names in queries
# prefixes = """PREFIX rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#>
# PREFIX xsd: <http://www.w3.org/2001/XMLSchema#>
# PREFIX hp: <https://deepset.ai/harry_potter/>
# """
# kg.prefixes = prefixes

Load the pre-trained retriever

from haystack.nodes import Text2SparqlRetriever


# Load a pre-trained model that translates text queries to SPARQL queries
kgqa_retriever = Text2SparqlRetriever(knowledge_graph=kg, model_name_or_path=Path(model_dir) / "hp_v3.4")

Query Execution

We can now ask questions that will be answered by our knowledge graph! One limitation though: our pre-trained model can only generate questions about resources it has seen during training. Otherwise, it cannot translate the name of the resource to the identifier used in the knowledge graph. E.g. “Harry” -> “hp:Harry_potter”

query = "In which house is Harry Potter?"
print(f'Translating the text query "{query}" to a SPARQL query and executing it on the knowledge graph...')
result = kgqa_retriever.retrieve(query=query)
print(result)
# Correct SPARQL query: select ?a { hp:Harry_potter hp:house ?a . }
# Correct answer: Gryffindor

print("Executing a SPARQL query with prefixed names of resources...")
result = kgqa_retriever._query_kg(
    sparql_query="select distinct ?sbj where { ?sbj hp:job hp:Keeper_of_keys_and_grounds . }"
)
print(result)
# Paraphrased question: Who is the keeper of keys and grounds?
# Correct answer: Rubeus Hagrid

print("Executing a SPARQL query with full names of resources...")
result = kgqa_retriever._query_kg(
    sparql_query="select distinct ?obj where { <https://deepset.ai/harry_potter/Hermione_granger> <https://deepset.ai/harry_potter/patronus> ?obj . }"
)
print(result)
# Paraphrased question: What is the patronus of Hermione?
# Correct answer: Otter