Many joint entity relation extraction models setup two separated label spaces for the two sub-tasks (i.e., entity detection and relation classification). We argue that this setting may hinder the information interaction between entities and relations. In this work, we propose to eliminate the different treatment on the two sub-tasks' label spaces. The input of our model is a table containing all word pairs from a sentence. Entities and relations are represented by squares and rectangles in the table. We apply a unified classifier to predict each cell's label, which unifies the learning of two sub-tasks. For testing, an effective (yet fast) approximate decoder is proposed for finding squares and rectangles from tables. Experiments on three benchmarks (ACE04, ACE05, SciERC) show that, using only half the number of parameters, our model achieves competitive accuracy with the best extractor, and is faster. Extracting structured information from plain texts is a long-lasting research topic in NLP. Typically, it aims to recognize specific entities and relations for profiling the semantic of sentences. An example is shown in Figure 1, where a person entity David Perkins and a geography entity California have a physical location relation PHYS . Methods for detecting entities and relations can be categorized into pipeline models or joint models. In the pipeline setting, entity models and relation models are independent with disentangled feature spaces and output label spaces. In the joint setting, on the other hand, some parameter sharing of feature spaces (Miwa and Bansal, 2016; Katiyar and  Equal contribution. Cardie, 2017) or decoding interactions (Yang and Cardie, 2013; Sun et al., 2019) are imposed to explore the common structure of the two tasks. It was believed that joint models could be better since they can alleviate error propagations among sub-models, have more compact parameter sets, and uniformly encode prior knowledge (e.g., constraints) on both tasks. However, Zhong and Chen (2020) recently show that with the help of modern pre-training tools (e.g., BERT), separating the entity and relation model (with independent encoders and pipeline decoding) could surpass existing joint models. They argue that, since the output label spaces of entity and relation models are different, comparing with shared encoders, separate encoders could better capture distinct contextual information, avoid potential con-flicts among them, and help decoders making a more accurate prediction, that is, separate label spaces deserve separate encoders . In this paper, we pursue a better joint model for entity relation extraction. After revisiting existing methods, we find that though entity models and relation models share encoders, usually their label spaces are still separate (even in models with joint decoders). Therefore, parallel to (Zhong and Chen, 2020), we would ask whether joint encoders (decoders) deserve joint label spaces ? The challenge of developing a unified entity-relation label space is that the two sub-tasks are usually formulated into different learning problems (e.g., entity detection as sequence labeling, relation classification as multi-class classification), and their labels are placed on different things (e.g., words v.s. words pairs). One prior attempt (Zheng et al., 2017) is to handle both sub-tasks with one sequence labeling model. A compound label set was devised to encode both entities and relations. However, the model's expressiveness is sacrificed: it can detect neither overlapping relations (i.e., entities participating in multiple relation) nor isolated entities (i.e., entities not appearing in any relation). Our key idea of defining a new unified label space is that, if we think Zheng et al. (2017)'s solution is to perform relation classification during entity labeling, we could also consider the reverse direction by seeing entity detection as a special case of relation classification. Our new input space is a two-dimensional table with each entry corresponding to a word pair in sentences (Figure 1). The joint model assign labels to each cell from a unified label space (union of entity type set and relation type set). Graphically, entities are squares on the diagonal, and relations are rectangles off the diagonal. This formulation retains full model expressiveness regarding existing entity-relation extraction scenarios (e.g., overlapped relations, directed relations, undirected relations). It is also different from the current table filling settings for entity relation extraction (Miwa and Sasaki, 2014; Gupta et al., 2016; Zhang et al., 2017; Wang and Lu, 2020), which still have separate label space for entities and relations, and treat on/off-diagonal entries differently. Based on the tabular formulation, our joint entity relation extractor performs two actions, filling and decoding . First, filling the table is to predict each word pair's label, which is similar to arc prediction task in dependency parsing. We adopt the biaffine attention mechanism (Dozat and Manning, 2016) to learn interactions between word pairs. We also impose two structural constraints on the table through structural regularizations. Next, given the table filling with label logits, we devise an approximate joint decoding algorithm to output the final extracted entities and relations. Basically, it efficiently finds split points in the table to identify squares and rectangles (which is also different with existing table filling models which still apply certain sequential decoding and fill tables incre-mentally). Experimental results on three benchmarks (ACE04, ACE05, SciERC) show that the proposed joint method achieves competitive performances comparing with the current state-of-the-art extractors (Zhong and Chen, 2020): it is better on ACE04 and SciERC, and competitive on ACE05. 1 Meanwhile, our new joint model is fast on decoding ( 10 x faster than the exact pipeline implementation, and comparable to an approximate pipeline, which attains lower performance). It also has a more compact parameter set: the shared encoder uses only half the number of parameters comparing with the separate encoder (Zhong and Chen, 2020). Given an input sentence s = x 1 , x 2 , . . . , x | s | ( x i is a word), this task is to extract a set of entities E and a set of relations R . An entity e is a span ( e. span ) with a pre-defined type e. type  Y e (e.g., PER , GPE ). The span is a continuous sequence of words. A relation r is a triplet ( e 1 , e 2 , l ) , where e 1 , e 2 are two entities and l  Y r is a pre-defined relation type describing the semantic relation among two entities (e.g., the PHYS relation between PER and GPE mentioned before). Here Y e , Y r denote the set of possible entity types and relation types respectively. as a table filling task (multi-class classification between each word pair in sentence s ), as shown in Figure 1. For the sentence s , we maintain a table T | s || s | . For each cell ( i, j ) in table T , we assign a label y i,j  Y , where Y = Y e  Y r  {} (  denotes no relation). For each entity e , the label of corresponding cells y i,j ( x i  e. span , x j  e. span ) should be filled in e. type . For each relation r = ( e 1 , e 2 , l ) , the label of corresponding cells y i,j ( x i  e 1 . span , x j  e 2 . span ) should be filled in l . 2 While others should be filled in  . In the test phase, decoding entities and relations becomes a rectangle finding problem. Note that solving this problem is not trivial, and we propose a simple but effective joint decoding algorithm to tackle this challenge. In this section, we first introduce our biaffine model for table filling task based on pre-trained language models (Section 3.1). Then we detail the main objective function of the table filling task (Section 3.2) and some constraints which are imposed on the table in training stage (Section 3.3). Finally we present the joint decoding algorithm to extract entities and relations (Section 3.4). Figure 2 shows an overview of our model architecture. 3 3.1 Biaffine Model Given an input sentence s , to obtain the contextual representation h i for each word, we use a pre-trained language model (PLM) as our sentence encoder (e.g., BERT). The output of the encoder is { h 1 , . . . , h | s | } = PLM ( { x 1 , . . . , x | s | } ) , where x i is the input representation of each word x i . Taking BERT as an example, x i sums the corresponding token, segment and position embeddings. To capture long-range dependencies, we also employ cross-sentence context following (Zhong and Chen, 2020), which extends the sentence to a fixed window size W ( W = 200 in our default settings). To better encode direction information of words in table T , we use the deep biaffine attention mechanism (Dozat and Manning, 2016), which achieves impressive results in the dependency parsing task. Specifically, we employ two dimension-reducing 2 Assuming no overlapping entities in one sentence. 3 We only show three labels of Y in Figure 2 for simplicity and clarity. MLPs (multi-layer perceptron), i.e., a head MLP and a tail MLP, on each h i as h head i = MLP head ( h i ) , h tail i = MLP tail ( h i ) , where h head i  R d and h tail i  R d are projection representations, allowing the model to identify the head or tail role of each word. Next, we calculate the scoring vector g i,j  R |Y| of each word pair with biaffine model, g i,j = Biaff ( h head i , h tail j ) , Biaff ( h 1 , h 2 ) = h T 1 U 1 h 2 + U 2 ( h 1  h 2 ) + b , where U 1  R |Y| d  d and U 2  R |Y| 2 d are weight parameters, b  R |Y| is the bias,  denotes concatenation. After obtaining the scoring vector g i,j , we feed g i,j into the softmax function to predict corresponding label, yielding a categorical probability distribution over the label space Y as In our experiments, we observe that applying dropout in g i,j , similar to de-noising auto-encoding, can further improve the performance. 4 . We refer this trick to logit dropout And the training objective is to minimize L entry =  1 | s | 2 | s | (cid:88) i =1 | s | (cid:88) j =1 log P ( y i,j = y i,j | s ) , (1) where the gold label y i,j can be read from annotations, as shown in Figure In fact, Equation 1 is based on the assumption that each label is independent. This assumption sim-plifies the training procedure, but ignores some structural constraints. For example, entities and relations correspond to squares and rectangles in the table. Equation 1 does not encode this constraint explicitly. To enhance our model, we propose two intuitive constraints, symmetry and implication , which are detailed in this section. Here we introduce a new notation P  R | s || s ||Y| , de-noting the stack of P ( y i,j | s ) for all word pairs in sentence s . 5 4 We set dropout rate p = 0 . Symmetry We have several observations from the table in the tag level. Firstly, the squares corresponding to entities must be symmetrical about the diagonal. Secondly, for symmetrical relations, the relation triples ( e 1 , e 2 , l ) and ( e 2 , e 1 , l ) are equivalent, thus the rectangles corresponding to two counterpart relation triples are also symmetrical about the diagonal. As shown in Figure 1, the rectangles corresponding to (his, wife, PER-SOC ) and (wife, his, PER-SOC ) are symmetrical about the diagonal. We divide the set of labels Y into a symmetrical label set Y sym and an asymmetrical label set Y asym . The matrix P : , : ,t should be symmetrical about the diagonal for each label t  Y sym . We formulate this tag-level constraint as symmetrical loss, We list all Y sym in Table 1 for our adopted datasets. Implication A key intuition is that if a relation exists, then its two argument entities must also exist. In other words, it is impossible for a relation to exist without two corresponding entities. From the perspective of probability, it implies that the probability of relation is not greater than the probability of each argument entity. Since we model entity and relation labels in a unified probability space, this idea can be easily used in our model as the implication constraint. We impose this constraint on P : for each word in the diagonal, its maximum possibility over the entity type space Y e must not be lower than the maximum possibility for other words in the same row or column over the relation type space Y r . We formulate this table-level constraint as implication loss, where [ u ]  = max( u, 0) is the hinge loss. It is worth noting that we do not add margin in this loss function. Since the value of each item is a probability and might be relatively small, it is meaningless to set a large margin. Finally, we jointly optimize the three objectives in the training stage as L entry + L sym + L imp . 6 In the testing stage, given the probability tensor P  R | s || s ||Y| of the sentence s , 7 how to decode all rectangles (including squares) corresponding to entities or relations remains a non-trivial problem. Since brute force enumeration of all rectangles is intractable, a new joint decoding algorithm is needed. We expect our decoder to have, 6 We directly sum the three losses to avoid introducing more hyper-parameters. 7 For the symmetrical label t  Y sym , we set P i,j,t = P j,i,t = ( P i,j,t + P j,i,t ) / 2 . Simple implementation and fast decoding. We permit slight decoding accuracy drops for scalability. Strong interactions between entities and relations. When decoding entities, it should take the relation information into account, and vice versa. Inspired by the procedures of (Sun et al., 2019), We propose a three-steps decoding algorithm: decode span first (entity spans or spans between enti-ties), and then decode entity type of each span, and at last decode relation type of each entity pair (Fig-ure 3). We consider each cell's probability scores on all labels (including entity labels and relation labels) and predict spans according to a threshold. Then, we predict entities and relations with the highest score. Our heuristic decoding algorithm could be very efficient. Next we will detail the entire decoding process, and give a formal description in the Appendix A. Span Decoding One crucial observation of a ground-truth table is that, for an arbitrary entity, its corresponding rows (or columns) are exactly the same in the table (e.g., row 1 and row 2 of Figure 1 are identical), not only for the diagonal entries (entities are squares), but also for the off-diagonal entries (if it participates in a relation with another entity, all its rows (columns) will spot that relation label in the same way). In other words, if the adjacent rows/columns are different, there must be an entity boundary (i.e., one belonging to the entity and the other not belonging to the entity). Therefore, if our biaffine model is reasonably trained, given a model predicted table, we could use this property to find split positions of entity boundary. As expected, experiments (Figure 4) verify our assumption. We adapt this idea to the 3-dimensional probability tensor P . Specifically, we flatten P  R | s || s ||Y| as a matrix P row  R | s | ( | s ||Y| ) from row perspective, and then calculate the Euclidean distances ( l 2 distances) of adjacent rows. Similarly, we calculate the other Euclidean distances of adjacent columns according to a matrix P col  R ( | s ||Y| ) | s | from column perspective, and then average the two distances as the final distance. If the distance is larger than the threshold  (  = 1 . 4 in our default settings), this position is a split position. In this way, we can decode all the spans in O ( | s | ) time complexity. Entity Type Decoding Given a span ( i, j ) by span decoding, 8 we decode the entity type  t according to the corresponding square symmetric about the diagonal:  t = arg max t Y e {} Avg ( P i : j,i : j,t ) . If  t  Y e , we decode an entity. If  t =  , the span ( i, j ) is not an entity. Relation Type Decoding After entity type decoding, given an entity e 1 with the span ( i, j ) and another entity e 2 with the span ( m, n ) , we decode the relation type  l between e 1 and e 2 according to the corresponding rectangle. Formally,  l = arg max l Y r {} Avg ( P i : j,m : n,l ) . If  l  Y r , we decode a relation ( e 1 , e 2 ,  l ) . If  l =  , e 1 and e 2 have no relation. Datasets We conduct experiments on three entity relation extraction benchmarks: ACE04 (Dodding-ton et al., 2004), 9 ACE05 (Walker et al., 2006), 10 and SciERC (Luan et al., 2018). 11 Table 2 shows the dataset statistics. Besides, we provide detailed dataset specifications in the Appendix B. Evaluation Following suggestions in (Taille et al., 2020), we evaluate Precision (P), Recall (R), and F1 scores with micro-averaging and adopt the Strict Evaluation criterion. Specifically, a predicted entity is correct if its type and boundaries are correct, and a predicted relation is correct if its 8 i and j denote start and end indices of the span. 9 https://catalog.ldc.upenn.edu/LDC2005T09 10 https://catalog.ldc.upenn.edu/LDC2006T06 11 http://nlp.cs.washington.edu/sciIE/ Dataset Model Encoder Entity Relation P R F1 P R F1 ACE04 Li and Ji (2014) -83.5 76.2 79.7 60.8 36.1 45.3 Miwa and Bansal (2016) LSTM 80.8 82.9 81.8 48.7 48.1 48.4 Katiyar and Cardie (2017) LSTM 81.2 78.1 79.6 46.4 45.3 45.7 Li et al. (2019) BERTLARGE 84.4 82.9 83.6 50.1 48.7 49.4 Wang and Lu (2020) ALBERTXXLARGE-88.6 -59.6 Zhong and Chen (2020) (cid:5) BERTBASE-89.2 -60.1 Zhong and Chen (2020) (cid:5) ALBERTXXLARGE-90.3 -62.2 UNIRE (cid:5) BERTBASE 87.4 88.0 87.7 62.1 58.0 60.0 UNIRE (cid:5) ALBERTXXLARGE 88.9 90.0 89.5 67.3 59.3 63.0 ACE05 Li and Ji (2014) -85.2 76.9 80.8 65.4 39.8 49.5 Miwa and Bansal (2016) LSTM 82.9 83.9 83.4 57.2 54.0 55.6 Katiyar and Cardie (2017) LSTM 84.0 81.3 82.6 55.5 51.8 53.6 Sun et al. (2019) LSTM 86.1 82.4 84.2 68.1 52.3 59.1 Li et al. (2019) BERTLARGE 84.7 84.9 84.8 64.8 56.2 60.2 Wang et al. (2020) BERTBASE-87.2 -63.2 Wang and Lu (2020) ALBERTXXLARGE-89.5 -64.3 Zhong and Chen (2020) (cid:5) BERTBASE-90.2 -64.6 Zhong and Chen (2020) (cid:5) ALBERTXXLARGE-90.9 -67.8 UNIRE (cid:5) BERTBASE 88.8 88.9 88.8 67.1 61.8 64.3 UNIRE (cid:5) ALBERTXXLARGE 89.9 90.5 90.2 72.3 60.7 66.0 SciERC Wang et al. (2020) SciBERT -68.0 -34.6 Zhong and Chen (2020) (cid:5) SciBERT -68.2 -36.7 UNIRE (cid:5) SciBERT 65.8 71.1 68.4 37.3 36.6 36.9 Table 3: Overall evaluation. relation type is correct, as well as the boundaries and types of two argument entities are correct. Implementation Details We tune all hyper-parameters based on the averaged entity F1 and relation F1 on ACE05 development set, then keep the same settings on ACE04 and SciERC. For fair comparison with previous works, we use three pre-trained language models: bert-base-uncased (Devlin et al., 2019), albert-xxlarge-v1 (Lan et al., 2019) and scibert-scivocab-uncased (Beltagy et al., 2019) as the sentence encoder and fine-tune them in training stage. 12 For the MLP layer, we set the hidden size as d = 150 and use GELU as the activation function. We use AdamW optimizer (Loshchilov and Hutter, 2017) with  1 = 0 . 9 and  2 = 0 . 9 , and observe a phenomenon similar to (Dozat and Manning, 2016) in that setting  2 from 0.9 to 0.999 causes a significant drop on final performance. The batch size is 32, and the learning rate is 5e-5 with weight decay 1e-5. We apply a linear warm-up learning rate scheduler with a warm-up ratio of 0.2. We train our model with a maximum of 200 epochs (300 epochs for SciERC) and employ an early stop strategy. We 12 The first two are for ACE04 and ACE05, and the last one is for SciERC. Table 3 summarizes previous works and our UNIRE on three datasets. 13 In general, UNIRE achieves the best performance on ACE04 and SciERC and a comparable result on ACE05. Comparing with the previous best joint model (Wang and Lu, 2020), our model significantly advances both entity and relation performances, i.e., an abso-lute F1 of +0.9 and +0.7 for entity as well as +3.4 and +1.7 for relation, on ACE04 and ACE05 respectively. For the best pipeline model (Zhong and Chen, 2020) (current SOTA), our model achieves superior performance on ACE04 and SciERC and comparable performance on ACE05. Comparing with ACE04/ACE05, SciERC is much smaller, so entity performance on SciERC drops sharply. Since (Zhong and Chen, 2020) is a pipeline method, its relation performance is severely influenced by the poor entity performance. Nevertheless, our model is less influenced in this case and 13 Since (Luan et al., 2019a; Wadden et al., 2019) neglect the argument entity type in relation evaluation and underperform our baseline (Zhang et al., 2020), we do not compare their results here. achieves better performance. Besides, our model can achieve better relation performance even with worse entity results on ACE04. Actually, our base model (BERTBASE ) has achieved competitive relation performance, which even exceeds prior models based on BERTLARGE (Li et al., 2019) and ALBERTXXLARGE (Wang and Lu, 2020). These results confirm the proposed unified label space is effective for exploring the interaction between entities and relations. Note that all subsequent experiment results on ACE04 and ACE05 are based on BERTBASE for efficiency. In this section, we analyze the effects of components in UNIRE with different settings (Table 4). Particularly, we implement a naive decoding algorithm for comparison, namely hard decoding, which takes the intermediate table as input. The intermediate table is the hard form of probability tensor P output by the biaffine model, i.e., choosing the class with the highest probability as the label of each cell. To find entity squares on the diagonal, it first tries to judge whether the largest square ( | s |  | s | ) is an entity. The criterion is simply counting the number of different entity labels appearing in the square and choosing the most frequent one. If the most frequent label is  , we shrink the size of square by 1 and do the same work on two ( | s |  1)  ( | s |  1) squares and so on. To avoid entity overlapping, an entity will be discarded if it overlaps with identified entities. To find relations, each entity pair is labeled by the most frequent relation label in the corresponding rectangle. From the ablation study, we get the following observations. grees (line 2-3). Specifically, the symmetrical loss has a significant impact on SciERC (de-crease 1.1 points and 1.4 points for entity and relation performance). While removing the implication loss will obviously harm the relation performance on ACE05 (1.0 point). It demonstrates that the structural information incorporated by both losses is useful for this task. Comparing with the Default, the performance of w/o logit dropout and w/o cross-sentence context drop more sharply (line 4-5). Logit dropout prevents the model from overfit-ting, and cross-sentence context provides more contextual information for this task, especially for small datasets like SciERC. The hard decoding has the worst performance (its relation performance is almost half of the Default) (line 6). The major reason is that hard decoding separately decodes entities and relations. It shows the proposed decoding algorithm jointly considers entities and relations, which is important for decoding. Following (Zhong and Chen, 2020), we evaluate the inference speed of our model (Table 5) on ACE05 and SciERC with the same batch size and pre-trained encoders (BERTBASE for ACE05 and SciBERT for SciERC). Comparing with the pipeline method (Zhong and Chen, 2020), we obtain a more than 10  speedup and achieve a comparable or even better relation performance with W = 200 . As for their approximate version, our inference speed is still competitive but with better performance. If the context window size is set the same as (Zhong and Chen, 2020) ( W = 100 ), we can further accelerate model inference with slight performance drops. Besides, hard decoding is 0.0 0.5 1.0 1.5 2.0 2.5 3.0 Euclidean distance 0 2 4 6 8 D e n s i t y Types Ent-Bound Non-Ent-Bound Figure 4: Distributions of adjacent rows' distances for two categories with respect to the threshold  on ACE05 dev set. In Figure 4, the distance between adjacent rows not at entity boundary (Non-Ent-Bound) mainly concentrates at 0, while that at entity boundary (Ent-Bound) is usually greater than 1. This phenomenon verifies the correctness of our span decoding method. Then we evaluate the performances, with regard to the threshold  in Figure 5. 14 Both span and entity performances sharply decrease when  increases from 1.4 to 1.5, while the relation performance starts to decline slowly from  = 1 . 5 . The major reason is that relations are so sparse that many entities do not participate in any relation, so the threshold of relation is much higher than that of entity. Moreover, we observe a similar phenomenon on ACE04 and SciERC, and  = 1 . 4 is a general best setting on three datasets. It shows the stability and generalization of our model. In Table 4, both cross-sentence context and logit dropout can improve the entity and relation performance. Table 6 shows the effect of different context window size W and logit dropout rate p . The entity and relation performances are significantly improved from W = 100 to W = 200 , and drop sharply from W = 200 to W = 300 . Similarly, we achieve the best entity and relation performances when p = 0 . 2 . So we use W = 200 and p = 0 . 2 in our final model. We further analyze the remaining errors for relation extraction and present the distribution of five errors: span splitting error (SSE), entity not found (ENF), entity type error (ETE), relation not found (RNF), and relation type error (RTE) in Figure 6. The proportion of SSE is relatively small, which proves the effectiveness of our span decoding method. Moreover, the proportion of not found error is significantly larger than that of type error for both entity and relation. The primary reason is that the table filling suffers from the class imbalance issue, i.e., the number of  is much larger than that of other classes. We reserve this imbalanced classification problem in the future. Finally, we give some concrete examples in Figure 7 to verify the robustness of our decoding algorithm. There are some errors in the biaffine model's prediction, such as cells in the upper left corner (first example) and upper right corner (second example) in the intermediate table. However, these errors are corrected after decoding, which demonstrates that our decoding algorithm not only recover all entities and relations but also corrects errors leveraging table structure and neighbor cells' information. Entity relation extraction has been extensively studied over the decades. Existing methods can be roughly divided into two categories according to the adopted label space. Separate Label Spaces This category study this task as two separate sub-tasks: entity recognition and relation classification, which are defined in two separate label spaces. One early paradigm is the pipeline method (Zelenko et al., 2003; Miwa et al., 2009) that uses two independent models for two sub-tasks respectively. Then joint method handles this task with an end-to-end model to explore more interaction between entities and relations. The most basic joint paradigm, parameter sharing (Miwa and Bansal, 2016; Katiyar and Cardie, 2017), adopts two independent decoders based on a shared encoder. Recent span-based models (Luan et al., 2019b; Wadden et al., 2019) also use this paradigm. To enhance the connection of two decoders, many joint decoding algorithms are proposed, such as ILP-based joint decoder (Yang and Cardie, 2013), joint MRT (Sun et al., 2018), GCN-based joint inference (Sun et al., 2019). Actually, table filling method (Miwa and Sasaki, 2014; Gupta et al., 2016; Zhang et al., 2017; Wang et al., 2020) is a special case of parameter sharing in table structure. These joint models all focus on various joint algorithms but ignore the fact that they are essentially based on separate label spaces. Unified Label Space This family of methods aims to unify two sub-tasks and tackle this task in a unified label space. Entity relation extraction has been converted into a tagging problem (Zheng et al., 2017), a transition-based parsing problem (Wang et al., 2018), and a generation problem with Gold Table Intermediate Table Decoded Table   wings were off of it 903 American airlines flight VEHORGVEHART     Figure 7: Examples showing the robustness of our decoding algorithm. Seq2Seq framework (Zeng et al., 2018; Nayak and Ng, 2020). We follow this trend and propose a new unified label space. We introduce a 2D table to tackle the overlapping relation problem in (Zheng et al., 2017). Also, our model is more versatile as not relying on complex expertise like (Wang et al., 2018), which requires external expert knowledge to design a complex transition system. In this work, we extract entities and relations in a unified label space to better mine the interaction between both sub-tasks. We propose a novel table that presents entities and relations as squares and rectangles. Then this task can be performed in two simple steps: filling the table with our biaffine model and decoding entities and relations with our joint decoding algorithm. Experiments on three benchmarks show the proposed method achieves not only state-of-the-art performance but also promising efficiency. The authors wish to thank the reviewers for their helpful comments and suggestions. This work was (partially) supported by National Key Research and Development Program of China (2018AAA0100704), NSFC (61972250, 62076097), STCSM (18ZR1411500), Shanghai Municipal Science and Technology Major Project (2021SHZDZX0102), and the Fundamental Research Funds for the Central Universities.
abstain abstain objective abstain abstain method abstain result abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain result abstain abstain abstain abstain abstain abstain objective abstain abstain abstain abstain method abstain method abstain method abstain abstain objective abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain method method method method method abstain abstain method method method method abstain method abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain other method abstain method method abstain abstain abstain abstain abstain abstain abstain abstain method method abstain other abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain other abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain result abstain abstain result abstain result result abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain result abstain abstain abstain abstain result abstain abstain abstain abstain result abstain result abstain abstain abstain result abstain abstain abstain result abstain abstain abstain abstain result abstain abstain other other other other other other other other other other other abstain other objective method method method objective method abstain other other