Knowledge Based Question Answering (KBQA) is concerned with the possibility of querying data by posing questions in Natural Language (NL), that is by far, the most (human) common form of expressing an information need. This work reviews an approach to Question Answering that has the goal to transform Natural Language questions into SPARQL queries over cultural heritage knowledge bases. The key idea is to apply a rule-based classi cation process that we call template matching and that we have implemented in a prototype using logic programming. In the paper we discuss about the application of the prototype in real use-case, and indicate ongoing and future directions of work.
Reference Model [
Our QA approach can be described as a waterfall-like process in which a user
question is rst processed from a syntactic point of view and then from a
semantic point of view. Syntactic processing is based on the concept of template, where
a template represents a category of syntactically homogeneous sentence patterns
and is expressed in terms of Answer Set Programming (ASP) [
On the other hand, the semantic processing is based on the concept of intent.
By intent we mean the purpose (i.e., the intent) of the question: two questions
can belong to two disjoint syntactic categories but have the same intent and
vice versa. To give an example: who created Guernica? and who is the author of
Guernica? have a quite di erent syntactic structure, but have the same intent,
i.e., know who made the work Guernica. On the other hand, if we consider who
created Guernica? and who restored Guernica? we can say that they are
syntactically similar (or homogeneous), but semantically di erent: the purpose of the
two questions is di erent. Semantic disambiguation, in which intents are mapped
to a set of prede ned queries on the knowledge base, is done by resorting to the
multilingual BabelNet [
The goal of our approach is to answer questions on cultural heritage facts stored
in a repository modeled according to a standard model of this domain. In
particular, the target knowledge base model of the project is the CIDOC conceptual
reference model [
In this section we present step-by-step our question answering system for cultural heritage. In particular, the question answering process is split into the following phases: (1) Question NL Processing: the input question is transformed into a three-level syntactic representation; (2) Template Matching: the representation is categorized by a template system that is implemented by means of logical rules; (3) Intent Determination: the identi ed template is mapped to an intent, where the intent identi es precisely the intent (or purpose) of the question; (4) Query Generation: an intent becomes a query on the knowledge base; (5) Query Execution: the Query is executed on the knowledge base; (6) Answer Generation: the result produced by the query is transformed into a natural language answer. Splitting the QA process into distinct phases allowed us to implement a system by connecting loosely-coupled modules dedicated to each phase. In this way we also achieved better maintainability, and extensibility. In the following sections, we analyze in detail the 6 phases just listed. Question NL Processing The NL processing phase builds a formal and therefore tractable representation of the input question. The question is decomposed and analyzed by highlighting both the atomic components that compose it, and the morphological properties of the components and the relationships that bind them. In this phase we perform the following NLP steps: Named entities recognition, Tokenization, Part-of-speech tagging, and Dependency Parsing.
Named entities recognition (NER) is an NLP task that deals with the
identi cation and categorization of the entities that appear in a text. The named
entities are portions of text that identify the names of people, organizations,
places or other elements that are referenced by a proper name. For example, in
the phrase Michelangelo has painted the Last Judgment, we can recognize two
entities: Michelangelo, that could belong to a Person category, and the Last
Judgment that could belong to an Artwork category. When the entities of the
text have been recognized, they can be replaced with placeholders that are
easier to manage in the subsequent stages of processing of natural language. In our
implementation we use CRF++ [
Tokenization consists of splitting text into words (called tokens). A token is an indivisible unit of text. Tokens are separated by spaces or punctuation marks. In western languages, the tokenization phase turns out to be rather simple, as these languages place quite clear word demarcations. In fact, the approaches used for natural language tokenization are based on simple regular expressions. Tokenization is the rst phase of lexical analysis and creates the input for the next Part-of-Speech Tagging phase.
The Part-of-Speech tagging phase assigns to each word the corresponding part of the speech. Common examples of parts of speech are adjectives, nouns, pronouns, verbs, or articles. The Part-of-Speech assignment is typically implemented with supervised statistical methods. There are, for several languages, large manually annotated corpora that can be used as training sets to train a statistical system. Among the best performing approaches are those based on Maximum Entropy. For tokenization and POS-tagging we used the Apache OpenNLP library1 with pretrained models.
Finally, Dependency Parsing is the identi cation of lexical dependencies of
the words of a text according to a grammar of dependencies. The dependency
grammar (DG) is a class of syntactic theories that are all based on the
dependency relationship (as opposed to the circumscription relation). Dependency
is the notion that linguistic units, e.g., words, are connected to one another
by directed connections (or dependencies). A dependency is determined by the
relationship between a word (a head) and its dependencies. The methods for
extracting grammar dependencies are typically supervised and use a reference
tag-set and a standard input representation format known as the CoNLL
standard developed and updated within the CoNLL scienti c conference (Conference
on Computational Natural Language Learning). In our implementation we used
MaltParser2 that is a system for data-driven dependency parsing [
To this end, the output of the NLP phase is modeled by using ASP facts that constitute the input of the template matching module. In particular, words are indexed by their position in the sentence and they are associated with their morphological feature by using facts of the following forms: word(pst,wrd).
pos(pst,pos tag).
gr(pst1,pst2,rel tag). the rst kind of fact associates position of words (pst) in a sentence to the word itself (wrd); the second associates words (pst) with their POS tags (pos tag), 1 https://opennlp.apache.org 2 http://www.maltparser.org/ and the latter models grammatical relations (a.k.a. typed dependencies) specifying the type of grammatical relation (rel tag) holding among pair of words (pst1,pst2). The possible tags and relations terms are constants representing the labels produced by the NLP tools mentioned in the previous subsection.
Consider, for example, the question who painted Guernica?, the output of the NLP phase would result in the following facts: word(1, "who"). word(2, "painted"). word(3, "Guernica"). word(4, "?"). pos(1, pr). pos(2, vb). pos(3, np). pos(4, f). gr(2, 1, nsubj). gr(2, 3, dobj). gr(2, 4, punct).
In the template matching phase, questions are matched against question templates. Templates identify categories of questions that are uniform from the syntactic point of view and we express them in the form of ASP rules.
Basically, each template rule models a condition under which we identi ed a possible syntactic question pattern for a template. An example of template rule that matches questions of the form who action object? is the following: template(who action object, terms 2(V, O), 8) :word (1, "who"), word(2, V), word(3, O), word(4, "?"), pos(1, pr), pos(2, vb), pos(3, np), pos(4, f), gr(2, 1, nsubj), gr(2, 3, dobj), gr(2, 4, punct).
In the example, who action object is a constant that identi es the template, while terms(V; W ) is a function symbol that allows extracting the terms of the input question, respectively the verb V and the object O. The intuitive meaning of a template rule is that whenever all atoms in the body (the part of the rule a ter :-) are true, then the template matches. The number 8, is the weight of the template rule. The weight is a number expressing the importance of a pattern. By using weights one can freely express preferences; for instance in our implementation we set this number to the size of elements in the body of the ASP template rule to favor more speci c templates over more generic ones.
Question templates are intended to be de ned by the application designer, which is a reasonable choice in applications like the one we considered, where the number of templates to produce is limited. Nonetheless, to assist the de nition of templates we developed a graphical user interface. Such interface helps the user at building template rules by working and generalizing examples, and does not require any previous knowledge of ASP or speci c knowledge of NLP tools. The template editing interface is not described in this paper for space reasons.
In our prototype, we used DLV [
Intent Determination The identi cation of a question by templates might be
not su cient to identify its intent or purpose. For example, who painted
Guernica? and who killed Caesar? have similar syntactic structures and may fall into
the same template, but they have two di erent purposes. The intent
determination process is based on the lexical expansion of question terms extracted in the
template matching phase and has the role of identifying what the question asks
(i.e., its intent), starting from the result of the template matching phase. In other
words, it disambiguates the intent of questions that fall into the same syntactic
category. In the previous example, painting is hyponym (i.e., a speci c instance)
of creating and thus we can understand that the intent is to determine the
creator of a work, while killing does not have such relationships and we should,
therefore, instantiate a di erent intent. In the same way, who painted Guernica?,
who made Guernica? are questions that can be correctly mapped with a single
template and can be correctly recognized by the same intent thanks to the fact
that all three verbs are hyponyms or synonyms of the verb create. Words
semantic relations can be obtained by using dedicated dictionaries, like wordnet [
The implementation of intent determination is done by the designer as template de nition. Our system implements a set of intents that were identi ed during the analysis by a partner of the project.
Query Execution The intents identi ed in the previous phase are mapped one
to one with template queries, called prepared statements in programming jargon.
In the Query Execution phase, the query template corresponding to the identi ed
event is lled with the slots with terms extracted from the template matching
phase and executed over the knowledge base. The CIDOC-crm speci cation is,
by de nition, an RDF knowledge base [
We conducted an experimental analysis to assess the performance of the system on a set of 60 template rules, which are able to handle basic question forms and types for the cultural heritage domain distributed in 20 di erent intents.We report, on a sample of 167 questions, an average template matching time of 34 milliseconds (ms) on an Intel i7-7700HQ CPU architecture. For what concerns the other phases of the QA system, the NL phase average execution time is of 30 ms and is at most 50 ms, the intent determination phase average execution time is of 50 ms and is at most 580 ms and the average query execution time is of 8 ms and is at most 32 ms. Overall the system presents good execution times, which are acceptable for a real-time QA system. 3
In this work, we presented an approach to the problem of Knowledge-based Question Answering in the Cultural Heritage domain. The presented solution transforms input questions into SPARQL queries that are executed on a knowledge base. The concrete application of the approach to the Cultural Heritage use-case shows that one of the main advantages of the approach is that it is suited for fast prototyping, as it allows the fast integration of new question forms and new question intents. This feature suits the need of closed domains that are characterized by a limited number of intents and question forms. On the other hand a drawback of the approach is that it relies on the manual work of a designer that provides question templates and the strategy for intent matching. This problem is partly solved by some other QA approaches, as the ones based on machine learning that requires less engineering e orts in the implementation of question understanding at the cost of providing a corpora of examples.
The prototype can be seen as a good starting point for many future works.
One of the most natural observation that comes in mind is that the intent
determination phase can be also encoded using logic programs, thus making also the
speci cation of this step exible and independent from a static decision made at
compile time. Indeed, having the whole question understanding process in ASP
makes it more homogeneous and easier to develop and maintain. A prerequisite
of implementing intent determination in ASP is to make ASP code interact with
the dictionary that provides words semantic relations. We think that this can be
achieved either by porting dictionary data in ASP or by using ASP extensions
with external computation. Another interesting thing to investigate is how the
ASP-based implementation compares with other techniques for question
answering, as the ones only based on machine learning (e.g., [