KARL: Knowledge-Aware Reasoning Memory Modeling with Reinforcement Learning of Vector Space
Anonymous Author
Transactions of the ACL submission under open review
Abstract
Founded in
Atkinson-Shiffrin
Memory
Model’s three-stage theory, the cognitive process of answering a question with stored knowledge can be seen as a reasoning process that goes from the external sensory memory via short-term knowledge-aware reasoning towards the internal knowledge storage.
While in the machine, this process can be interpreted as a pipeline from encoding the questions information, through decoding the reasoning query of triples, towards the knowledgebase.
How to encode and decode the varying semantic information of question into accurate triple query, and how to adjust the query generation with an evolving knowledgebase, are two inevitable problems in this cognitive process.
Our model KARL, provides a solution by designing the three memory spaces as, an encoder to handle the language modeling, a decoder for query generation, and a self-calibration with reinforcement learning of the knowledge representation vector space.
We evaluate the model’s reasoning ability in knowledge-based question answering against the Question Answering over Linked Data (QALD) benchmark, and achieve signiﬁcant improvements in answers accuracy as compared to other neural models.
Introduction
The Atkinson and Shiffrin Model(Atkinson and
Shiffrin, 1968) of memory states gives proof for modeling the reasoning process as a three-stage and multi-store pipeline that consists of the sensory memory, the short-term memory and the long-term memory.
Theoretically, the sensory memory is for extracting and holding the external information, while the short-term memory represents the knowledge-aware mental activities of reasoning, and the long-term memory is as the storage of memorized knowledge.
In our modeling, we compare the machine reasoning as a knowledge-based question answering (KBQA)(Yahya et al., 2012; Cui et al., 2019) three-stage problem where a machine perceives a natural language question and interpret it into a query of entity-relation triples then querying towards the answer entity in knowledgebase.
And herein lies three problems: ﬁrst, given the ﬂexibility of language, how to perceive the varying semantic information from a question is inevitable for a machine; second, its about the appropriate representation for the query of triples(Arias et al., 2011); third, a strategy for the models learning to adjust with the modiﬁcation of knowledgebase should be self-evolutionary(Lehmann et al., 2015).
However, to the best of our knowledge, the recent researches of machine knowledge-aware reasoning(Ding et al., 2019; Das et al., 2017; Soru et al., 2018) always show less focus either on the varying of semantics (e.g. the polysemy and the synonymy), or on the studies about the self-calibration to an evolving knowledge, which calls for more attention to the comprehensive modeling that can multilaterally combine all into a complete cognitive process.
The semantic meanings in natural language are abstract and varying, while the entities and relations in a knowledge graph (e.g. DBpedia,
Wikidata)(Lehmann et al., 2015; Vrande?i?
and
Krtzsch, 2014) are extracted and reﬁned in a format of concrete nodes with connecting edges.
The same question can be asked using different sentences with different vocabularies, and that the same vocabulary has biased meanings in different sentences.
What’s more, the knowledge graph is dynamic, for instance, the entity node for a famous star named X used to have an relation edge named spouse with another entity Y , but after they get divorced and married again to others, the edge spouse of X would have been reconnected to another entity maybe named Z .
Although in these cases the answer’s explicit node content changed, the natural language sentences, no matter ”Who is the spouse of X ?”, ”Who is the husband of X ?” or ”Which one is married to X?”, the logic structure like triple (cid:104) entity ( X ) , relation ( spouse ) , entity (? variable ) (cid:105) is unchanged during reasoning, with its semantic similarity remains in vector space, which also keeps stable the SPARQL query(Arias et al., 2011; P´erez et al., 2006) for answering this question in knowledge graph i.e. SELECT ?
var
W HERE { dbr : X dbo : spouse ? var. } .
This opens the opportunity to build the reward function with reinforcement learning algorithms of vector space to self-calibrate the query generation.
In our model, we base a sequence-to-sequence structure integrated with the pretrained language model BERT on the reinforcement learning of knowledge embedding vector space, to imitate a threecomponent cognitive process for knowledge-aware reasoning.
The Sensory Memory is as the ﬁrst component to begin with the modeling. Due to the variety of semantic biases in contexts, the phenomenon of polysemy and synonymy is frequent in asking the questions, especially when the questions are only short sentences.
To disambiguate these semantic biases, the support of pretrained language model that have learned a vast content of language materials is necessary in universal language representation.
Here we leverage the pretrained BERT in our modeling.
We incorporate the BERT into the attention-based encoder part in the sequence-tosequence structure for the question encoding.
In the second component, the Short-term Memory, the major architecture is a decoder also based on attention mechanism.
The role for this component is to decode the question encoding from the ﬁrst component into a SPARQL query(Arias et al., 2011; El-Roby and Ammar, 2018) to fetch the entity from a knowledge graph, such as DBpedia.
Finally, in the third component, after vectorizing the generated SPARQL queries in the second component with global vectors for word representation(GloVe)(Pennington et al., 2014), we tune the model’s training loss function to build the reinforcement learning algorithm that optimizes the semantic distance between the targeted entity of the generated query and the plausible answer entity of the golden query.
Background and Related Works
We brieﬂy introduce the background of reasoning models for knowledge-based question answering and review current techniques.
2. Memory Models
In cognitive science, the researches of memory models(Atkinson and Shiffrin, 1968; Baddeley, 2018) theorize the conscious awareness process of human perceiving and retrieving memories as a continuation of multiple stages.
The AtkinsonShiffrin model advocates that human memories consists of three separate components, namely, the sensory register, where the perceived information enters memory, the short-term holding memory, also called working memory or short-term memory, where as an interface that handles both the inputs from sensory register and the retrieval of stored long-term memory, and the long-term store, where the learned knowledge are stored for a long period.
Expanding Atkinson and Shiffrin’s work,
the
Baddeley’s Model of Working Memory(Baddeley, 2018) presents a more detailed modeling of shortterm memory, where the working memory during human’s simultaneous pondering and reasoning on the perceived information is considered as an independent processing unit of instant memories instead of just a sub-component of the short-term memory.
These two studies provide a supportive theorem to our model KARL to compute the interaction between the short-term extracted information from natural language texts and the longterm information stored in knowledge graph.
In computer science, computational models inspired by Memory Model theories proved the feasibility of implementation in the domain of dialog question answering generation(Chen
et al., 2019) and questionanswering(Wang and Nyberg, 2015).
But, unlike the prior design(Chen et al., 2019) which incorporated the long-term memories into both the encoder’s and the decoder’s structures, our model takes the knowledge graph in the component for
Long-term Memory, as the role of long-term memory and considers the generated query vector in
Component II as the representation of short-term memory.
2. Knowledge-Based Question Answering
For the recently published knowledge-based question answering models(Cui et al., 2019; Ding et al., 2019; Das et al., 2017; Huang et al., 2019) which also make an attempt to give the answer to a question with explainable reasoning, they store their knowledge in three styles of methods.
The models of the ﬁrst style(Cui et al., 2019) is to store knowledge in the traditional type of knowledge graph, such as Wikidata and DBpedia, which are already prepared and ﬁxed external knowledge bases.
On the contrary, the second type(Ding et al., 2019) tried to build the graph from texts as the model training goes on, whose knowledge base, in short, can be generated by the instant segmentation or extraction when building the model.
The third type, it shows an ambition to go beyond the restricted structure of nodes connected with edges, instead they transform the graph into homogeneous or heterogeneous embedding spaces.
But for this type of method(Huang et al., 2019), on one hand it alleviates the limitations brought by a ﬁxed graph structure on the other hand it requires more time and resource to train a set of embedding(Yang et al., 2014) from a knowledge graph at the cost of losing much explicit information in the concrete nodes and edges.
What’s more, once the knowledge graph gets re-edited, i.e. several nodes modiﬁed or a few edges redirected even deleted which causes an impact over the whole graph, then the embedding needs to be trained again.
The strategies used by current knowledge-based question answering models can be typically classiﬁed into two branches.
The ﬁrst is to search for a path and arrive at the answer’s node in the knowledge graph.
The path-searching, it can be done by pattern matching of the text (i.e. matching some phrases or vocabulary) in a graph that’s constructed with the segmented parts from texts, or it can be helped by algorithms of reinforcement learning in wandering the path towards the right answer node with a simpliﬁed reward function that if it’s right path then return a positive reward value else return a negative value to update its learning state.
Architecture
The model architecture can be seen as three components to bridge the gaps among the three states.
The cognitive process is perpetuated with the three-state pipeline.
3. Sensory Memory
The Sensory Memory component of our model is a question encoder incorporated with a pre-trained language model.
3.1. Language Modeling
The pretrained language model(Dai et al., 2019;
Radford, 2018; Devlin et al., 2018) helps the model in better extracting the semantic information from a rather short question sentence that lacks of abundant contextual background information.
The pretrained language model works in two layers, in the architecture’s sequence-to-sequence encoder, and in decoder (Sutskever et al., 2014).
This design is grounded in the previous efforts from neuroscience and psychological experiments(Cao and Perfetti, 2016; Kuhl, 2010; May L, 2011) on the observation and analyses of how human brain neural structure differently responses to reading familiar and unlearned languages(Cao and Perfetti, 2016; Kuhl, 2010) and how the psychological activities develop during these readings(May L, 2011).
These researches assert that a pre-acquired language system(May L, 2011) for a learned language is necessary in the process of perceiving external information into internal sensory memory.
Without the pre-acquisition of the language, it is not only impossible to interpret the language into our memory system but also tended to cause the psychological anxiety for unlearned language with a vibration effect in the neural aspect.
Thus, in our computational cognitive modeling of memory states for reasoning in knowledge-based question answering, it is reasonable and essential to introduce the pretrained language model to serve the role as the pre-acquired language system works in interpreting the information from natural language question sentences.
In regards to the length limited and the lack of context of a question sentence, the semantic bias can be a problem in the process of comprehensively and multilaterally interpreting the sentence into sensory memory.
For example, the question ”where is the bank of paris” can be both the river beach of Paris city and a ﬁnancial institution of
Paris.
Without the pre-trained language model, the encoding for such sentences will be unilateral and limited in information.
First, in the encoder, the BERT(Devlin et al., 2018) outputs the embedded sentence tensor as the input of the Encoder-attention layer.
Through this process, the sentence get weighted by the trained parameters in the pretrained model which is proven to be efﬁcient in universal language
representation(Edunov et al., 2019).
Our model incorporates the BERT into encoder-decoder gets inspiration from the BERT-fused-NMT(anonymous, 2019).
Then, in the decoder, there’s also an attention layer that accepts the sentence embedding from BERT.
This strongly helps in better maintaining the semantic information of question sentence all along through the encoder to the decoder.
3.1. Encoder
We construct the encoder with an attention layer and a feed-forward layer.
The attention layer(Vaswani et al., 2017) consists of two attention mechanisms to compute the output from pretrained language model and the tokens index tensor from the embeddings of the segmentation of sentence.
We use the general design of attention layer from the paper(Vaswani et al., 2017), denoting the
Key , V alue , and Query in the original algorithm as K , V , and Q , then the attention layer is deﬁned as
[Equation]
Then we build the multi-head attention function as follows, the concat is the function to concatenate the tensors,
[Equation]
which’s used in the Encoder-attention , Selfattention of encoder, the Encoder-decoder Attention , Decoder-attention of decoder depicted in the
Figure22.
The structure of feed-forward layers in our model is position-wise feed-forward network(Vaswani et al., 2017; Ott et al., 2019) that each time adds up the two outputs from the previous two attention mechanisms through layer normalization(Vaswani et al., 2017).
This structure is also used in both the encoder and the decoder.
3. Short-term Memory
The Short-term Memory is the decoder part for the query tensor generation, where reﬂects the explainable logic reasoning of the triples in the question sentence.
3.2. Decoder
The decoder component consists of three layers.
The ﬁrst is an attention layer, following with the second attention layer, and the last is a feedforward layer.
The second layer is stacked with two parallel attention mechanism that respectively accepts the output tensor from the last layer of encoder and the output from the pre-trained language model, and the outputs of these two attention mechanisms will be added and normalized at the end of the second layer as the input for the third layer.
At last, as the output of the third layer, a query tensor is generated, which represent a SPARQL query sentence that can fetch back a correspondent entity in the knowledge graph.
The generated query tensor is a one-dimension integer tensor, in which each integer element is a numeric index of one token in SPARQL language.
To better understand how the SPARQL query works in interpreting the basic logic structure of the entities and relations in a question sentence, Figure44 is two examples that visualized the comparison and relation of the natural language question with its tokenized SPARQL representation and the matching answer entity in knowledge graph.
3.2. Generation of Query Tensor
This Figure-4 4 displays the two types of queries in SPARQL language.
In a query, the core is the clause starting with WHERE surrounded by two braces.
The ﬁrst type starting with SELECT is to query a certain entity node.
And, the second type starting with ASK , different from the ﬁrst type, is to assert whether the RDF relations described in the WHERE exist, if it exists return True else False .
In the WHERE clause, there are single or multiple triples in the form of (cid:104) head entity, relation, tail entity (cid:105) , e.g.in the examle for Type.1 (cid:104) var, dbo : restingP lace, dbr :
Great P yramid of Giza (cid:105) , and the triples are separated by a dot .
In these triple, those tokens starts with string var are the representative symbols of those undetermined entities.
So, these generated query tensors can be mapped to a list of SPARQL tokens and join into a string of query which’s able to fetch back certain entities nodes through the server endpoint of a knowledge.
Even though the graph construction of a knowledge base is periodically modiﬁed, the verbal form of query for th certain answer can remain stable.
In some rare cases, although the name of ceratin entity or relation will get renamed, e.g. the Obama, dateOfBirth, var might turn to Obama, birthday, var , the semantic similarity based on vector cosine distance between the adding-up of embeddings of Obama and dateOfBirth the embedding of Obama and birthday .
As a result, according to the algorithm of
TransE(Bordes et al., 2013), in the embedding vector space of knowledge representation, the entity head plus the relation equals to the entity tail , and the entity tail minus the relation equals to the entity head .
3.2. Reasoning with the Query Tensor
SPARQL Query SPARQL query can be considered as a path that can wind through the entity nodes and relation edges and ﬁnally arrive at the answer node.
The interesting part of SPARQL is, its nodes and edges are determined by their verbal form of names, i.e. the composition of the vocabularies used in the names of the entity or relation.
In short, as an analogy that may be not very descriptive, our sequence-to-sequence model is an laser-gun sharpshooter who picks up the natural language questions as the bullets and shot different bullets as laser vectors in different directions into the vector space, as the vector space develops our model learns to adjust the shooting and improves its hit rate at the target entities.
Reasoning The generated query tensor, after embedding, will be parsed into a graph of triples for non-monotonic reasoning(Hunter, 2018).
That’s to say, preasuming that in each triple we have head + relation = tail in the knowledge-graph vector space following closed-world assumption, if a triple is defaulted (i.e., the triple contains the uncertain variable entity), the defaulted variable entity can be represented by: vector ( entity head ) =
vector ( entity tail ) − vector ( relation ) , if entity head is var ; vector ( entity tail ) =
vector ( entity head ) + vector ( relation ) ,if entity tail is variable.
Similar to TransE(Bordes et al., 2013), we use GloVe(Pennington et al., 2014) to embed the tokens in triple to calculate the representation vector for the query in vector space.
For instance, the token for the entity of
City of Westminster in SPARQL language is dbr:City of Westminster , then the embedding for this entity is the add-up of the GloVe embedding of the city and the Westminster after removing the stop-word the .
The algorithm for calculating the query representation vector ??
is a loop: if the triple contains only one variable, the variable can be easily calculated by the other two certain elements intriple; else if the triple contains more than one variable, we search other triples that contains one of these variables.
If the searched triple also contains variable in addition to the previous one, we trace the new variable back to search other triples.
This will be considered as build the triples of the query into a graph with tree structure in Figure44.
3. Long-term Memory
In Long-term Memory, there are two major parts: the knowledge graph, and the reward function.
The reward function is the core of the reinforcement learning of vector space, where the SPARQL query towards the knowledgebase is turned into a vector and this vector’s distance is the objective to be optimized.
3.3. Knowledge Graph As Vector Space
The long-term knowledge storage structure of the
Sensory Memory component in our model KARL is the knowledge graph of DBpedia.
A knowledge graph can be represented in an embedding vector space, where the entities and relations are mapped as vectors in the vector space.
This is highly efﬁcient for a more direct computation of the triples, in the form of calculable embedding tensors.
In the embedding representation of knowledge graph, which is elaborated in the methodology of TransE(Bordes et al., 2013) and DistMult(Yang et al., 2014), the problem of pointing the query toward the answer entity can be achieved with the arithmetic operations of the embedding tensors.
Thus, we transform the embedding vector space of a knowledge graph into a vectorized environment for reinforcement learning.
3.3. Reward Function And Reinforcement Learning
Since the query can be embedded into a vector that arrows at certain point in the space, the metric for how to measure the loss between the generated query tensor and the correct query tensor is deﬁned as a function that calculates the similarity based on cosine distance.
The objective function is to maximize the similarity by minimizing their cosine distance.
To design our reward function, we ﬁrst set a label-smoothed cross-entropy function to get the loss of distribution of the generated query as the basis value of the reward.
Then, on this basis, we calculate the cosine similarity between generated query and its standard correct query to get a value as an additional weight for the basis cross-entropy loss value.
Finally, the model multiplies the basis cross-entropy loss with the weight of cosine similarity.
After the training of each epoch, by comparing the current loss of the latest epoch with the best loss among the previous epochs, the model automatically select the training state with the best performance to update for optimization in the training.
States:
Deﬁning the whole embedding vector space as the state space S with all its valid triples T = { ( e head , r, e tail ) | e head ∈ E, e tail ∈
E, r ∈ R } , T ∈ S where R and E denote all entities and relations in S .
the model KARL is the agent that’s expected to transform the natural language question through a sequence-to-sequence structure into the query tensor that represents the basic logic triples in the form of SPARQL query language, in order to point the query as accurately as possible to the answer entity.
Thus, a state is represented by the generated query tensors q ∈ Q , Q = { t ( e head , r, e tail ) | e head ∈ E, e tail ∈ E, r ∈
R, t ∈ T } .
Observations: The agent KARL observes the natural language questions, interpreting them to query tensors that are as close as possible to the expected target entity in the graph.
Actions: The actions are the query tensor generation3.2.2.
The generated query tensor from interpreting its natural language question is required to contain all the triples with the potential entities and relation in the question to form a sequence of
SPARQL query to reach the answer entity.
Transition: The model’s training evolution for the environment is driven by the semantic similarity distance(Wieting et al., 2019) towards the target.
The transition is achieved by updating the loss of the generation distribution of the query tensor, by means of minimizing the label-smoothed cross-entropy(M¨uller et al., 2019) loss compared with the distribution of the optimal query.
The label-smoothing turns the label y k into y LSk , with denoting p t as the probability of correct generation, to get y LSk =
y k (1 − α )
+ α, y k ∈ { 0 , 1 } , then the label-smoothed cross-entropy is deﬁned as
[Equation]
Reward: The rewards in the vector space of knowledge graph are continuous, and this reward is considered as a weighted value on the basis of the label-smoothed cross-entropy loss.
Denote by R , vector gen , and vector gold respectively the reward, the generated query’s embedding vector, and the correspondent golden-standard query’s embedding vector, with setting R ∈ [1 , 2] , the reward is deﬁned as
[Equation]
where the sim is the similarity function from the equation() mentoned above.
Experiment 4. Main Experiment
The encoder-decoder structure in our model is implemented with the help of the package Fairseq(Ott et al., 2019).
4.1. Dataset
The datasets for the experiments contain the source data which are natural language questions and
the target data which’re
the corresponding SPARQL queries that provide the basic entity-relation tokens(Ricardo Usbeck and Ngomo, 2018;
Soru et al., 2018) and syntactic structure(El-Roby and Ammar, 2018) for the model to learn.
Our training data is from the DBNQA(Marx, 2018), and we evaluate the model’s reasoning performance in knowledgebased question answering with the tasks in QALD datasets.
Training Data
The DBNQA is the dataset for training our model.
To the best of our knowledge, it is the largest natural language to SPARQL dataset with different samples of SPARQL queries from different development versions of the DBpedia.
As a result, the queries in DBNQA contains not triples from multiple previous modiﬁcations.
Thus, it is one sufﬁcient resource dataset to learning about the changes in the verbal forms and the triple relations.
Preprocessing To enlarge the vocabulary volume for interpretation and generation also handling the out-of-vocabulary phenomenon, the BPE(byte pair encoding)(Sennrich et al., 2015) method from neural machine translation is introduced into the preprocessing works of both the source and target data.
We use BPE to get te subtokens of all the vocabulary, and these subtokens are made into a vocabulary dictionary with unique integer indexes for each subtokens.
During the sequence-to-sequence structure that turns natural language questions into query tensors, the vocabulary dictionary helps in handling those vocabularies that are unprecedented in the training dataset, which on one hand fortiﬁes the model’s ﬂexibility and capacity in dealing with the modiﬁcation of entities and relation in knowledge graph, on the other hand also improves its ability in interpreting the ﬂexible composition of words in the natural languge quetions.
4.1. Evaluation
The QALD is an annual challenge for knowledgebased question answering which provides updated datasets that match each year’s modiﬁcation in the knowledgebase of DBpedia.
QALD provides the task where multilingual question answering over
DBpedia is available in eleven different languages (e.g., English, Spanish, German, Italian, French,
Dutch, Romanian or Farsi).For our evaluation, we currently choose the datasets for knowledge-based question answering in English.
Each data item contains a SPARQL query with its questions written in multiple languages4.
In our experiments, we denote the given two ofﬁcial datasets, the qald-9-train-multilingual.json and the qald-9-testmultilingual.json , as Set-I and Set-II .
4.1. Results
For fair experiments, the evaluations were all run on the online server of GERBIL 1 which is the ofﬁcial open platform to provide QALD bench.
To the best of our knowledge, the NSpM(Soru et al., 2018) is the precedent state-of-the-art in neural models which depends on translating natural language questions into SPARQL queries with neural machine translation methods, we compare our model’s performance with NSpM’s, the results were calculated and recorded by GERBIL.
Up to now, the non-neural models have been dominating the leaderboard, and the previous neural models are not yet comparable with the nonneural ones.
In table1, we show signiﬁcant improvement compared to the neural model NSpM,.
In Set-I , as the highest score in leaderboard2, our model is 52.78 percent higher than the precedent neural model in F-1 score1; in Set-II , as the one neural model that can be comparable with the rulebased models, our model is 27.18 percent higher than the precedent neural model in F-1 score1.
It is of our contribution to largely improve the neural model’s performance in knowledge-based question answering benchmarks.
[Table]
[Table]
on both the train- set and test-set.
However, to see our model’s performance on adjusting with modiﬁed versions of knowledge graph, we trained our model KARL on the DBNQA dataset that contains no-longer valid queries.
And, the DBNQA dataset was earlier before the publication of QALD-9 dataset.
Thus, the QALDdatasets are suitable for evaluating the knowledge-based ques- tion answering ability in spite of the modiﬁcations varying with time.
[Table]
4. Experiments on Ablation Study 4.2. Question Encoding
To investigate the differences in question encoding brought by incorporating different pre-trained language models, we use customized K-means(Pelleg and Moore, 1999) with setting cosine-based similarity as the metric for the distance between question embeddings.
In QALD, each answer for the question are classiﬁed into different categories in the knowledge graph, and this is the label for classi- ﬁcation.
Here, denote by x , µ the encoded tensor and the cluster centroid respectively, we deﬁne the similarity function as
[Equation]
The clustering algorithm updates by calculating S ( t ) i
[Equation]
k (cid:9) with the µ ( t
[Equation]
to optimize the objective function
[Equation]
Denote by Accu , C the probability of predicted category for the cluster and the prediction accuracy by
the similarity-based clusteringrespectively,
[Equation]
We use Set-I as training set and Set-II as testing set.
Their results are shown in the Table 33:
According to Table2, it shows that: ﬁrst, the encoders with pre-trained language model performs better than the one without pre-trained model; second, the one with XLNet achieves higher but subtle score than the one with BERT.
4.2. Decoder
The Table-4 4 compares structures using different decoders.
The structure with decoder of bideirectional-RNN(Sutskever et al., 2014) and the structure with decoder of vanilla Transformer(Vaswani et al., 2017) do not achieve signiﬁcant improvement compared to 1 performance on F-1 score.
And their improvements are not competable with the non-neural models in Figure2.
C2KB
P2KB
RE2KB
Macro-F1 on QALD
[Table]
4.2. Vector Space
The generated query tensor is parsed into a vector pointing towards the answer in knowledge-graph vector space.
We conduct the experiment to evaluate the answer prediction ability by ranking the cosine-based similarity between the query vector and all the vectors of answer entities in the SetI and Set-II .
The MRR(Mean Reciprocal Rank), Hits@10 and Hits@100 are to measure the accuracy that the vector can infer to the correct answer
[Table]
[Table]
[Table]
Discussion and Conclusion
In the model KARL, we propose a computational cognitive modeling of the memory model for reasoning on knowledge-based question answering.
The research of how the external information is transformed then connected towards the stored information via an explainable logic process is still of much empty space to be explored.
In addition, by challenging the previous leaderboard dominated by rule-based and matching-based systems, our methodology KARL demonstrates the feasibility of neural reasoning modeling in knowledge-based question answering, showing signiﬁcant improvements in benchmarks.
Why does the model build vectors for entities with the GloVe instead of the knowledge embeddings?
As we have discussed in the previous section2.1, we focus on the reasoning modeling that can maintain stable in spite of the periodical modiﬁcations of the knowledgebase, which in human cognition is the belief revision(Chi, 2008; van Benthem, 2007), i.e., the re-edition of stored knowledge.
And, the modiﬁcation of a knowledge graph will inevitably cause biases upon its previous embeddings.
We would hope to ﬁnd a method that can be of certain level of independence to the knowledgebase.
The SPARQL query can be considered as a path to arrive at the expected answer entity.
However, if a query is only represented by list of tokens, the query easily gets expired when it losses its semantic meanings during the knowledge modiﬁcation and tokens change.
Thus, we evaluated how well this vectoring method can achieve in the experiment5 of ranking evaluations on answers prediction.
In fact, is the SPARQL query a restriction of the development of knowledge-based reasoning and question-answering?
Surely yes, not only the query but also the knowledge graph itself is a barrier, as one’s own self is just its own biggest enemy.
The query, entity(node) and relation(edge) in a knowledge graph are categorised into the ontologies, however, the relations and ontologies for the same item can be varying according to different contexts.
Thus, a computable probabilistic graph model for knowledge storing will be better in handling the likelihood of choosing the right path when standing at one entity and facing multiple existing relation edges, for instance, if an entity both has the relation edges husband and wife , in complex context, which relation is more pertinent for the context who is her spouse .
For the future works: As the two questions discussed above, we will continue to: (1) Autosimultaneous vectorization of the knowledge base, which gets rid of the training the embeddings again when the knowledge graph modiﬁes.
(2) Work on more profound knowledge-graph reasoning.
We are currently staying in an initial stage for exploring the logic on knowledge, and the computational non-monotonic reasoning modeling is worth more attention.