| Frame: Activity_stop | Frame: Process_stop |
| Def | An Agent ceases an Activity without completing it | A Process stops at a certain Time and Place |
| FEs | core: Agent, Activity peripheral: Degree, Duration, Manner, Time extra-thematic: Depictive,Purpose, Result,... | core: Process peripheral: Manner, Place, Time extra-thematic: Depictive, Duration, ... |
| LUs | abandon.v, cease.v, halt.v, quit.v, stop.v, ... | cease.v, halt.n, shutdown.n, stop.v,... |
| FRs | Inherits from: Process_stop Subframe of: Activity Is Inherited by: Halt Uses: Eventive_affecting | Inherits from: Event Subframe of: Process Is Inherited by: Activity_stop |
Table 1: The structured descriptions for frame Activity_stop versus frame Process_stop in FrameNet1.7. The description of a frame is mainly composed of frame definition (Def), frame elements (FEs), lexical units (LUs) and frame-to-frame relations (FRs). Note that the elements of FEs, LUs and FRs are partially listed due to the limited space†. Lexical unit is expressed in the form of lemmaPOS (e.g. stop.v).
tion, and merely treat them as discrete labels.
The recent studies of FI use distributed representations of target words and their syntactic context to construct features, and construct classification models with deep neural network (Hartmann et al., 2017; Kabbach et al., 2018). These methods usually transform frame labels into one-hot representations (Hermann et al., 2014; Tackström et al., 2015), and then learn the embeddings of target words and frames simultaneously. However, the abundant semantic information and structure knowledge of frames contained in FrameNet are still neglected.
Knowledge of frames defined by linguists, such as frame definition, frame elements and frame-to-frame relations, can enrich frame labels with rich semantic information that can potentially guide FI models to learn more unique and distinguishable representations. Thus, in this paper, we propose a Knowledge Guided Frame Identification framework (KGFI) which consists of a Bert-based context encoder and a frame encoder based on a specialized graph convolutional network (FrameGC-N). In particular, the frame encoder incorporates multiple types of frame knowledge into frame representation which guides the KGFI to jointly map target words and frames into the same embedding space. Instead of predicting the frame label directly, KGFI chooses the best suitable frame evoked by the target word in a given sentence by calculating the dot-product similarity scores between the target word embedding and all of the frame embeddings. In summary, our contribution is threefold:
- To the best of our knowledge, we are the
first to propose a unified FI method which leverages heterogeneous frame knowledge for building rich frame representations.
- We design a novel Framework KGFI, consisting of a Bert-based context encoder and a GCN-based frame encoder, which learns the model from a combination of annotated data and FrameNet knowledge base, and maps target words and frames into the same embedding space.
- Extensive experimental results demonstrate our proposed KGFI framework outperforms the state-of-the-art models across two benchmark datasets.
# 2 FrameNet and FI Task Definition
# 2.1 FrameNet
FrameNet is built on the hypothesis that people understand things by performing mental operations on what they already know (Baker et al., 1998). Such knowledge reflecting people's cognitive experience is described as structured information packets called frames. A frame represents an event scenario, associated with a set of semantic roles (frame elements (FEs)). Lexical units (LUs) are capable of evoking the scenario (Kshirsagar et al., 2015). Frame elements in terms of how central they are to a particular frame can be divided into three distinguishing levels: core, peripheral and extra-thematic. Each frame has a textual definition (Def), depicting the scenario and how the roles interact in the scenario. Frames are organized as a network with several kinds of frame-to-frame relations (FRs).
Figure 2: The overall architecture of KGFI.
Table 1 shows the structure of frame Activity_stop and frame Process_stop in FrameNet.
# 2.2 FI Task Definition
Frame Identification (FI) is the task of predicting a frame evoked by the target word in a sentence. Let $\mathbf{c} = w_0, w_1, \dots, w_{st}, \dots, w_{en}, \dots, w_n$ denote a given sentence, and $\mathbf{t} = w_{st}, \dots, w_{en}$ ( $t \subset c$ ) represent the target word, where $st$ and $en$ are the start and end index respectively for the target word $\mathbf{t}$ in the sentence. Let $F = (f_1, f_2, \dots, f_{|F|})$ denote the set of all frames in FrameNet. The FI model is defined as a mapping function $G: (\mathbf{c}, \mathbf{t}, st, en) \to f_j$ , subject to $f_j \in F$ .
# 3 Methodology
Table 1 illustrates the structured knowledge (Def, FEs, LUs) of two different frames and their frame-to-frame relations (FRs). We explicitly leverage them to enrich the frame embeddings with semantic information. The resulted informative frame representations serve two purposes: 1) guide our model to learn more distinguishable embeddings of target words, and 2) improve FI model's generalization performance in the prediction phase.
The proposed KGFI framework consists of three components: context encoder, frame encoder and scoring module, as shown in Figure 2. Specifically, context encoder is used to represent the context-aware target word into an embedding with a Bert-based module, and frame encoder is used to incorporate three types of knowledge about a frame into frame embeddings. With the guidance of the knowledge about frames, two encoders jointly learn the embeddings of target words and frames. Finally, a scoring module is used to calculate the similarity scores between the given target word embedding and all frames' embeddings, to identify the best frame with the highest score.
# 3.1 Context Encoder
To get the context-aware embeddings of target words, we employ Bert (Devlin et al., 2019) for our context encoder, since its architecture is a multilayer bidirectional Transformer which can aggregate information from context into the target word through the self-attention mechanism. As we know, Bert model is pre-trained on a large corpus and can transfer language knowledge into the context encoder, which is very helpful for the target word representation as the manually labeled training data of FI is very small.
The context encoder, which we define as $E_{c}$ , takes given sentence $\mathbf{c}$ containing a target word $\mathbf{t}$ as input. We denote the last layer of Bert's output as $H_{t}$ . The context encoder can be expressed as:
$$
r _ {t} = E _ {c} (\mathbf {c}, \mathbf {t}, s t, e n) = W _ {c} ^ {T} h _ {t} + b _ {c} \tag {1}
$$
where
$$
h _ {t} = \frac {1}{e n + 1 - s t} \sum_ {i = s t} ^ {e n} \left(H _ {t} [ i ]\right), \tag {2}
$$
$W_{c}\in \mathbb{R}^{n\times m}$ and $b_{c}\in \mathbb{R}^{m}$ are learned parameters.
# 3.2 Frame Encoder
In FrameNet, all the frames are connected into a directed graph through the frame-to-frame relations, as shown in Figure 3. Moreover, the graph convolutional network(GCN) (Kipf and Welling, 2017) has been proved to be effective to model the relationship between labels (Yan et al., 2019; Chen et al., 2019; Cheng et al., 2020; Linmei et al., 2019), and it can enrich the representation of the node through aggregating information from its neighbors. In order to make better use of frame knowledge and the advantage of GCN, we propose a specialized GCN, called FrameGCN, to incorporate multiple frame knowledge into frame representations.
Figure 3: The sub-graph of overall graph of FrameNet1.7 corresponding to frame Activity_stop and Process_stop. The nodes denote frames and the directed edges denote frame-to-frame relations. The black $\rightarrow$ , red $\rightarrow$ and blue $\rightarrow$ denote Inheritance, Using and Subframe relations respectively, and the direction of an arrow is from super-frame to sub-frame.
# 3.2.1 Structure of FrameGCN
FrameGCN is a combination of two dedicated GCNs (FEsGCN and DefGCN) and an attention network, as shown in Figure 2. FEsGCN is used to represent frame by aggregating the FEs features of its neighbors, while DefGCN is used to represent frame by aggregating the Def features of its neighbors. The attention network is responsible for incorporating the outputs of two GCNs into one unified embedding where adjacent matrix $A$ is shared by the two dedicated GCNs.
Frame-to-frame relation in FrameNet is a symmetric relation between two frames, where one frame is called super-frame and the other is called sub-frame, as shown in Figure 3. A frame typically obtains/inherits more information from its super-frame than from its sub-frame. Therefore, we define the adjacent matrix of the graph as a weighted asymmetric matrix denoted as $A = (a_{ij})_{|F|\times |F|}$ where
$$
a _ {i j} = \left\{ \begin{array}{l l} 3, & f _ {j} = f _ {i} \\ 2, & f _ {j} \text {i s a s u p e r - f r a m e o f} f _ {i} \\ 1, & f _ {j} \text {i s a s u b - f r a m e o f} f _ {i} \\ 0, & \text {o t h e r} \end{array} . \right. \tag {3}
$$
Three types of frame-to-frames relations, including Inherits, Using and Subframe, are used in this study.
# 3.2.2 FEsGCN
The FEs of a frame express its semantic roles and structure. Frames which have similar structures imply that they have close semantic, so we regard FEs as features and use them to represent frames. Let $FE = (e_1, e_2, \ldots, e_{|FE|})$ denote
the set of all frame elements in FrameNet, and $V_{e} \in \mathbb{R}^{|F| \times |FE|}$ denote the feature matrix of frames represented by FEs. The $i$ th row of $V_{e}$ is the feature vector of $i$ th frame $f_{i}$ , and can be expressed as $V_{e}[i,:] = (ve_{1}, ve_{2}, \dots, ve_{|FE|})$ , where
$$
v e _ {j} = \left\{ \begin{array}{l l} 1, & e _ {j} \in F E _ {f _ {i}} \\ 0, & o t h e r \end{array} , \right. \tag {4}
$$
$FE_{f_i} \subset FE$ is the FEs of frame $f_i$ .
FEsGCN is used to learn a map function which maps the node (frame) vectors represented by FEs to a new representation via convolutional operation defined by $A$ . We take a two-layer GCN to implement the map function, which can be expressed as:
$$
\begin{array}{l} g _ {e} ^ {(0)} (A, V _ {e}) = R e L U \left(A V _ {e} W _ {e} ^ {(0)}\right), \\ g _ {e} ^ {(1)} (A, V _ {e}) = \operatorname {T a n h} \left(A g _ {e} ^ {(0)} (A, V _ {e}) W _ {e} ^ {(1)}\right). \tag {5} \\ \end{array}
$$
Here, $W_{e}^{(0)} \in \mathbb{R}^{|FE| \times h}$ is an input-to-hidden weight matrix for the hidden layer and $W_{e}^{(1)} \in \mathbb{R}^{h \times m}$ is a hidden-to-output weight matrix.
# 3.2.3 DefGCN
Since the frame definition is a short text that depicts an event scenario and frame elements that participate in the event, we employ Bert as a feature extractor to construct the feature matrix $V_{d}$ of frames. Specifically, we first input a frame definition into Bert, and subsequently take the first token's representation (corresponding to the input [CLS] token) in Bert's last layer as the feature vector of the frame. Since the name of a frame is also meaningful, we concatenate the frame name and frame definition into one string, e.g. Activity stop: an agent ceases an activity without completing it.
DefGCN is used to learn a map function which maps the node (frame) vectors represented by definition to a new representation via convolutional operation defined by $A$ . We use a network similar to FEsGCN, which can be expressed as:
$$
\begin{array}{l} g _ {d} ^ {(0)} (A, V _ {d}) = R e L U \left(A V _ {d} W _ {d} ^ {(0)}\right), \\ g _ {d} ^ {(1)} (A, V _ {d}) = \operatorname {T a n h} \left(A g _ {d} ^ {(0)} \left(A, V _ {d}\right) W _ {d} ^ {(1)}\right). \tag {6} \\ \end{array}
$$
Here, $W_{d}^{(0)} \in \mathbb{R}^{n \times h}$ is an input-to-hidden weight matrix for a hidden layer with $h$ feature maps, and $W_{e}^{(1)} \in \mathbb{R}^{h \times m}$ is a hidden-to-output weight matrix.
# 3.2.4 Attentive Graph Combination
We use an attention network to dynamic incorporate the outputs of FEsGCN and DefGCN into one frame embedding through the attention weighting
mechanism. The incorporation operation takes the following function:
$$
r _ {f _ {i}} = \sum_ {k \in \{e, d \}} a _ {i, k} g _ {k} ^ {(1)} (A, V _ {k}) _ {i} \tag {7}
$$
where $r_{f_i} \in \mathbb{R}^m$ is the embedding of $i$ th frame, $g_k^{(1)}(A, V_k)_i$ is the $i$ th row of convolved representation of graph $k$ , and $a_{i,k}$ is a weight of $i$ th frame against the graph $k$ , which is computed as:
$$
a _ {i, k} = \frac {\exp \left(w _ {a} g _ {k} ^ {(1)} \left(A , V _ {k}\right) _ {i}\right)}{\sum_ {k ^ {\prime} \in \{e , d \}} \exp \left(w _ {a} g _ {k ^ {\prime}} ^ {(1)} \left(A , V _ {k ^ {\prime}}\right) _ {i}\right)} \tag {8}
$$
where $w_{a}\in \mathbb{R}^{m}$ is a learnable vector.
# 3.3 Scoring and Prediction
After obtaining the embeddings of target words and frames through context encoder and frame encoder respectively, we score a target word $t$ with each frame $f_{j} \in F$ by computing the dot product similarity between $r_t$ and each $r_f$ for $f_{j} \in F$ :
$$
S \left(r _ {t}, r _ {f _ {j}}\right) = r _ {t}. r _ {f _ {j}}, j = 1, 2, \dots , | F | \tag {9}
$$
During training, all model parameters are jointly learned by minimizing a cross-entropy loss:
$$
L (\theta) = - \frac {1}{| D |} \sum_ {i} ^ {| D |} \sum_ {j} ^ {| F |} y _ {i j} \log \left(\hat {y} _ {i j}\right) \tag {10}
$$
where $D$ is the number of the training data, $|F|$ is the total number of frames in FrameNet, $y_{ij}$ (one-hot representation of frame labels) and $\hat{y}_{ij}$ are true labels. The predicted probability over frames is calculated by the softmax function over the scores.
During prediction, we predict the frame evoked by the target word $t$ to be $f_{j} \in F$ , whose representation $r_{f_j}$ has the highest score with $r_t$ . The prediction function is defined as:
$$
\hat {f} = \operatorname {a r g m a x} _ {f _ {j} \in F} S \left(r _ {t}, r _ {f _ {j}}\right) \tag {11}
$$
Note most of the frames contain a set of lexical units (LUs) in the form of lemmaPOS (e.g. stop.v). As shown in Table 1, the LUs of the frame Activity stop and the frame Process stop are listed in the fourth row. Therefore, we adopt the lexicon filtering operation to reduce the possible candidate frame set. Firstly, we utilize lemmatization and POS tools to convert the target word $t$ into the form of LU (e.g. stop.v). Secondly, we use this LU to match the frames whose LUs contains this LU, and then use the matched frames as the possible candidate frame set $F_{t}$ for the target word $t$ . At last, we predict the frame label by the following function: