PluDG: enhancing task-oriented dialogue system with knowledge graph plug-in module

Utterance encoder

Assuming that there are K turns in the dialogue history, the history contains 2K − 1 utterances, where each utterance includes L_i words. The words in the ith utterance are represented by word w_il, where L ∈ [1, L_i]. First, a Bi-GRU, which includes both a forward unit and a backward unit, is used to obtain the hidden representation of the sentences: (2)${\displaystyle H_i=h_{i1},h_{i2},h_{i3},\dots ,h_{il}=BiGRU\left(Emb\left(w_{il}\right)\right),}$ where Emb(w_il) represents the embedding state of the word w_il.

Next, a self-attention unit is utilized to capture the contextual information of each token in order to obtain a comprehensible semantic representation of the utterance, as shown below: (3)${\displaystyle {\mu }_{il}=tanh\left(W_w{h}_{il}+b_w\right),}$ (4)${\displaystyle {\alpha }_{il}=\frac{exp\left({\mu }_{il}{u}_w\right)}{\sum _{l}exp\left({\mu }_{il}{u}_w\right)},}$ (5)${\displaystyle v_i=\sum _l{\alpha }_{il}{h}_{il},}$ where W_w, b_w, u_w are trainable parameters of the model.

Lastly, a GRU is utilized to encode the utterance vector v_i: (6)${\displaystyle H_i^c=GRU\left(v_i\right),i\in \left[1,2K-1\right].}$

Context knowledge encoder

The Context Knowledge Encoder is employed to extract hidden information from both the dialogue history and knowledge base.

Context-KB Alignment. Following Chen et al. (2017), the Context-KB Alignment module aims to capture the alignment representation of each entity in the knowledge base through the incorporation of dialogue history. To achieve this goal, an attention mechanism is employed to align the dialogue history embedding with the knowledge base entity embedding, allowing for the creation of a coherent representation of the graph. Specifically, the module concatenates each word w_il with the entity representation e, applies a tanh activation, and derives attention scores through a Softmax operation. These scores are then multiplied with the corresponding words and summed to generate an aligned representation of the entity’s conversation history: (7)${\displaystyle c_{il}=tanh\left(W_e\left[Emb\left(e\right);Emb\left(w_{il}\right)\right]+b_e\right),}$ (8)${\displaystyle {\alpha }_{il}=\frac{exp\left(c_{il}{u}_e\right)}{\sum _{l}exp\left(c_{il}{u}_e\right)},}$ (9)${\displaystyle f_{align}^i\left(e\right)=\sum _l{\alpha }_{il}Emb\left(w_{il}\right),}$ where W_e, b_e, and u_e are trainable weight parameters, and [; ] denotes the concatenation.

Next, the jth entity embedding Emb(e_j) is concatenated with its correspondingly aligned embedding $f_{align}^i\left(e_j\right)$. In this way, we obtain a sequence of history-alignment entity input representations. Then, the sequence is passed to the GRU unit to obtain a more robust history-alignment entity representations. Formally, for each entity e_j, the representation f_ij is obtained as follow: (10)${\displaystyle f_{ij}=GRU\left(\left[Emb\left(e_j\right);f_{align}^i\left(e_j\right)\right]\right).}$

Knowledge Graph Encoder. In this section, we introduce a GCN (Kipf & Welling, 2016) to extract the intrinsic features of the knowledge graph. However, inspired by Hu et al. (2021), we leveraged the low-rank decomposition into the weights of GCN and named this new module LR-GCN. For given weights W₀ ∈ ℜ^x×y, we use W_o + ΔW = W_o + BA to replace the update, where B ∈ ℜ^x×y, A ∈ ℜ^y×z, and y <  < min(x, z).

In this section, we represent each entity as a node, where N represents the set of nodes. The relationships between entities are denoted as edges, and R represents the set of edges. Following the Context-KB Alignment operation, each entity in the dialog history has 2K − 1 representations, which correspond to the 2K − 1 utterances spoken. To capture the features from each node and its neighborhoods, we employ the GCN in the Graph operation: (11)${\displaystyle g_{ij}=\sigma \left(\sum _{r\in R}\sum _{v\in N_i^r}\frac{1}{\left|N_i^r\right|}{W}_r{f}_{iv}+W_0{f}_{ij}\right).}$

In Eq. (11), $N_i^r$ denotes the set of neighborhood-indices of entity i under relation r, r ∈ R; W_r and W_o are trainable parameters. An activation function σ() is adopted in this research, and ReLU is the specific function utilized.

Finally, an appropriate pooling method is used to fuse the data in g_ij and f_ij to obtain a question and text representation matrix G^f: (12)${\displaystyle {\vartheta }_{ij}=tanh\left(W_g\left[f_{ij};g_{ij}\right]+b_g\right),}$ (13)${\displaystyle {\alpha }_{il}=\frac{exp\left({\vartheta }_{ij}{u}_g\right)}{\sum _{l}exp\left({\vartheta }_{ij}{u}_g\right)},}$ (14)${\displaystyle g_i^f=\sum _l{\alpha }_{il}\left[f_{ij};g_{ij}\right],}$ where W_g, b_g, and u_g are trainable weight parameters, [; ] denotes the concatenation, and $G^f=\left[g_1^f,\dots ,g_{\left(2K-1\right)}^f\right]$.

Entity reasoner

The entity reasoner is an important component of the Kg-Plug. In this component, we concatenate the Utterance Encoder’s output and Context Knowledge Encoder’s output as $q_0^r$, formally: (15)${\displaystyle q_0^r=\left[H^c;G\right],}$ then use to two-hop attention to get the final entity probability.

Two-Hop update. In the reason stage, followed by the MemNN, we design a two-hop update mechanism to get the precise entity. For the sake of clarity in our description, we denote the number of hops as X, where X = 2. For the given hidden state, $q_0^r$, we use learnable attention to search for deeper information. In each hop have the following: (16)${\displaystyle q_{i+1}^r=tanh\left(W_q{q}_i^r\right),i\in \left[0,X\right].}$

In the final hop, we use the Softmax function to get the final entity probability p^ent: (17)${\displaystyle p^{ent}=Softmax\left(G^T{W}_e{q}_X^r\right).}$