SlowGuess/ACL_2020_OCR huggingface dataset:
Thanh-Tung Nguyen†, Xuan-Phi Nguyen†, Shafiq Joty§, Xiaoli Li†  
†Nanyang Technological University  
§Salesforce Research Asia  
†Institute for Infocomm Research, A-STAR  
Singapore  
{ng0155ng@e.; nguyenxu002@e.; srjoty@}ntu.edu.sg  
x1li@i2r.a-star.edu.sg
We propose a novel constituency parsing model that casts the parsing problem into a series of pointing tasks. Specifically, our model estimates the likelihood of a span being a legitimate tree constituent via the pointing score corresponding to the boundary words of the span. Our parsing model supports efficient top-down decoding and our learning objective is able to enforce structural consistency without resorting to the expensive CKY inference. The experiments on the standard English Penn Treebank parsing task show that our method achieves 92.78 F1 without using pre-trained models, which is higher than all the existing methods with similar time complexity. Using pre-trained BERT, our model achieves 95.48 F1, which is competitive with the state-of-the-art while being faster. Our approach also establishes new state-of-the-art in Basque and Swedish in the SPMRL shared tasks on multilingual constituency parsing.
Constituency or phrase structure parsing is a core task in natural language processing (NLP) with myriad downstream applications. Therefore, devising effective and efficient algorithms for parsing has been a key focus in NLP.
With the advancements in neural approaches, various neural architectures have been proposed for constituency parsing as they are able to effectively encode the input tokens into dense vector representations while modeling the structural dependencies between tokens in a sentence. These include recurrent networks (Dyer et al., 2016; Stern et al., 2017b) and more recently self-attentive networks (Kitaev and Klein, 2018).
The parsing methods can be broadly distinguished based on whether they employ a greedy transition-based algorithm or a globally optimized
Span Representation
$$
\mathcal {S} (T) = \left\{ \right.\left( \right.(1, 5), \mathrm {S}), ((2, 5), \varnothing), ((2, 4), \mathrm {V P}), ((3, 4), \mathrm {S - V P}) \left. \right\}
$$
Pointing Representation
$$
\mathcal {P} (T) = \left\{\left(1 \rightarrow 5, \mathrm {S}\right), \left(2 \rightarrow 5, \varnothing\right), \left(3 \rightarrow 4, \mathrm {S - V P}\right), \left(4 \rightarrow 2, \mathrm {V P}\right), \left(5 \rightarrow 1, \mathrm {S}\right)\right\}
$$
Figure 1: A binarized constituency tree for the sentence "She enjoys playing tennis." The node  $S - VP$  is an example of a collapsed atomic label. We omit POS tags and singleton spans for simplicity. Below the tree, we show span and pointing representations of the tree.
chart parsing algorithm. The transition-based parsers (Dyer et al., 2016; Cross and Huang, 2016; Liu and Zhang, 2017) generate trees autoregressively as a form of shift-reduce decisions. Though computationally attractive, the local decisions made at each step may propagate errors to subsequent steps which would suffer from exposure bias.
Chart parsing methods, on the other hand, learn scoring functions for subtrees and perform global search over all possible trees to find the most probable tree for a sentence (Durrett and Klein, 2015; Gaddy et al., 2018; Kitaev and Klein, 2018; Kitaev et al., 2019). In this way, these methods can ensure consistency in predicting structured output. The limitation, however, is that they run slowly at  $\mathcal{O}(n^3)$  or higher time complexity.
In this paper, we propose a novel parsing approach that casts constituency parsing into a series of pointing problems (Figure 1). Specifically,
3284
Proceedings of the 58th Annual Meeting of the Association for Computational Linguistics, pages 3284-3294 July 5 - 10, 2020. ©2020 Association for Computational Linguistics
our parsing model estimates the pointing score from one word to another in the input sentence, which represents the likelihood of the span covering those words being a legitimate phrase structure (i.e., a subtree in the constituency tree). During training, the likelihoods of legitimate spans are maximized using the cross entropy loss. This enables our model to enforce structural consistency, while avoiding the use of structured loss that requires expensive  $\mathcal{O}(n^3)$  CKY inference (Gaddy et al., 2018; Kitaev and Klein, 2018). The training in our model can be fully parallelized without requiring structured inference as in (Shen et al., 2018; Gomez and Vilares, 2018). Our pointing mechanism also allows efficient top-down decoding with a best and worse case running time of  $\mathcal{O}(n\log n)$  and  $\mathcal{O}(n^2)$ , respectively.
In the experiments with English Penn Treebank parsing, our model without any pre-training achieves 92.78 F1, outperforming all existing methods with similar time complexity. With pre-trained BERT (Devlin et al., 2019), our model pushes the F1 score to 95.48, which is on par with the state-of-the-art (Kitaev et al., 2019), while supporting faster decoding. Our model also performs competitively on the multilingual parsing tasks in the SPMRL 2013/2014 shared tasks and establishes new state-of-the-art in Basque and Swedish. We will release our code at https://ntunlpsg.github.io/project/parser/ptrconstituency-parser
Similar to Stern et al. (2017a), we view constituency parsing as the problem of finding a set of labeled spans over the input sentence. Let  $S(T)$  denote the set of labeled spans for a parse tree  $T$ . Formally,  $S(T)$  can be expressed as
$$
\mathcal {S} (T) := \left\{\left(\left(i _ {t}, j _ {t}\right), l _ {t}\right) \right\} _ {t = 1} ^ {| \mathcal {S} (T) |} \text {f o r} i _ {t} <   j _ {t} \tag {1}
$$
where  $|S(T)|$  is the number of spans in the tree. Figure 1 shows an example constituency tree and its corresponding labeled span representation.
Following the standard practice in parsing (Gaddy et al., 2018; Shen et al., 2018), we convert the  $n$ -ary tree into a binary form and introduce a dummy label  $\varnothing$  to spans that are not constituents in the original tree but created as a result of binarization. Similarly, the labels in unary chains corresponding to nested labeled spans are collapsed into unique atomic labels, such as S-VP in Fig. 1.
Although our method shares the same "span-based" view with that of Stern et al. (2017a), our approach diverges significantly from their framework in the way we treat the whole parsing problem, and the representation and modeling of the spans, as we describe below.
2.1 Parsing as Pointing
In contrast to previous approaches, we cast parsing as a series of pointing decisions. For each index  $i$  in the input sequence, the parsing model points it to another index  $p_i$  in order to identify the tree span  $(i,p_i)$ , where  $i\neq p_i$ . Similar to Pointer Networks (Vinyals et al., 2015a), each pointing mechanism is modeled as a multinomial distribution over the indices of the input tokens (or encoder states). However, unlike the original pointer network where a decoder state points to an encoder state, in our approach, every encoder state  $h_i$  points to another encoder state  $h_{p_i}$ .
In this paper, we generally use  $x \to y$  to mean  $x$  points to  $y$ . We will refer to the pointing operation either as a function of the encoder states (e.g.,  $h_i \to h_{p_i}$ ) or simply the corresponding indices (e.g.,  $i \to p_i$ ). They both mean the same operation where the pointing function takes the encoder state  $h_i$  as the query vector and points to  $h_{p_i}$  by computing an attention distribution over all the encoder states.
Let  $\mathcal{P}(T)$  denote the set of pointing decisions derived from a tree  $T$  by a transformation  $\mathcal{H}$ , i.e.,  $\mathcal{H}: T \to \mathcal{P}(T)$ . For the parsing process to be valid, the transformation  $\mathcal{H}$  and its inverse  $\mathcal{H}'$  which transforms  $\mathcal{P}(T)$  back to  $T$ , should both have a one-to-one mapping property. Otherwise, the parsing model may confuse two different parse trees with the same pointing representation. In this paper, we propose a novel transformation that satisfies this property, as defined by the following proposition (proof provided in the Appendix).
Proposition 1 Given a binary constituency tree  $T$  for a sentence containing  $n$  tokens, the transformation  $\mathcal{H}$  converts it into a set of pointing decisions  $\mathcal{P}(T) = \{(i \rightarrow p_i, l_i) : i = 1, \dots, n-1; i \neq p_i\}$  such that  $(\min(i, p_i), \max(i, p_i))$  is the largest span that starts or ends at  $i$ , and  $l_i$  is the label of the nonterminal associated with the span.
To elaborate further, each pointing decision in  $\mathcal{P}(T)$  represents a specific span in  $S(T)$ . The pointing  $i\rightarrow p_i$  is directional, while the span that it represents  $(i^{\prime},j^{\prime})$  is non-directional. In other words, there may exist position  $i$  such that  $i > p_{i}$ ,
while  $i' < j'\forall i',j'\in [1,n]$ . In fact, it is easy to see that if the token at index  $i$  is a left-child of a subtree, the largest span involving  $i$  starts at  $i$ , and in this case  $i < p_i$  and  $i^{\prime} = i,j^{\prime} = p_{i}$ . On the other hand, if the token is a right-child of a subtree, the respective largest span ends at position  $i$ , in which case  $i > p_i$  and  $i^{\prime} = p_{i},j^{\prime} = i$  (e.g., see  $4\to 2$  in Figure 1). In addition, as the spans in  $\mathcal{S}(T)$  are unique, it can be shown that the pointing decisions in  $\mathcal{P}(T)$  are also distinct from one another (see Appendix for a proof by contradiction).
Given such pointing formulation, for every constituency tree, there exists a trivial case  $(1\to n,l_{1})$  where  $p_1 = n$  and  $l_{1}$  is generally 'S'. Thus, to make our formulation more general with  $n$  inputs and  $n$  outputs and convenient for the method description discussed later on, we add another trivial case  $(n\to 1,l_1)$ . With this generalization, we can represent the pointing decisions of any binary constituency tree  $T$  as:
$$
\mathcal {P} (T) = \left\{\left(i \rightarrow p _ {i}, l _ {i}\right): i = 1, \dots , n; i \neq p _ {i} \right\} \tag {2}
$$
The pointing representation of the tree in Figure 1 is given at the bottom of the figure. To illustrate, in the parse tree, the largest phrase that starts or ends at token 2 ('enjoys') is the subtree rooted at '∅', which spans from 2 to 5. In this case, the span starts at token 2. Similarly, the largest phrase that starts or ends at token 4 ('tennis') is the span "enjoys playing tennis", which is rooted at 'VP'. In this case, the span ends at token 4.
Algorithm 1 describes the procedure to convert a binary tree to its corresponding pointing representation. Specifically, from each leaf token  $i$ , the algorithm traverses upward along the hierarchy until the non-terminal node that does not start
or end with  $i$ . In this way, the largest span starting or ending with  $i$  can be identified.
2.2 Top-Down Tree Inference
In the previous section, we described how to convert a constituency tree  $T$  into a sequence of pointing decisions  $\mathcal{P}(T)$ . We use this transformation to train the parsing model (described in detail in Sections 2.3 - 2.4). During inference, given a sentence to parse, our decoder with the help of the parsing model predicts  $\mathcal{P}(T)$ , from which we can construct the tree  $T$ . However, not all sets of pointings  $\mathcal{P}(T)$  guarantee the generation of a valid tree. For example, for a sentence with four (4) tokens, the pointing  $\mathcal{P}(T) = \{(1 \to 4, l_1), (2 \to 3, l_2), (3 \to 4, l_3), (4 \to 1, l_1)\}$  does not generate a valid tree because token '3' cannot belong to both spans (2, 3) and (3, 4). In other words, simply taking the arg max over the pointing distributions may not generate a valid tree.
Our approach to decoding is inspired by the span-based approach of Stern et al. (2017a). In particular, to reduce the search space, we score for span identification (given by the pointing function) and label assignment separately.
Span Identification. We adopt a top-down greedy approach formulated as follows.
$$
k ^ {*} = \arg \max  _ {k} s _ {\text {s p l i t}} (i, k, j) \tag {3}
$$
where  $s_{\mathrm{split}}(i,k,j)$  is the score of having a split-point at position  $k$  ( $i \leq k < j$ ), as defined by the following equation.
$$
s _ {\text {s p l i t}} (i, k, j) = \rho (k \rightarrow i) + \rho (k + 1 \rightarrow j) \tag {4}
$$
where  $\rho (k\to i)$  and  $\rho (k + 1\rightarrow j)$  are the pointing scores (probabilities) for spans  $(i,k)$  and  $(k + 1,j)$ , respectively. Note that the pointing scores are asymmetric, meaning that  $\rho (i\rightarrow j)$  may not be equal to  $\rho (j\rightarrow i)$ , because pointing from  $i$  to  $j$  is different from pointing from  $j$  to  $i$ . This is different from previous approaches, where the score of a span is defined to be symmetric. We build a tree for the input sentence by computing Eq. 3 recursively starting from the full sentence span  $(1,n)$ .
In the general case when  $i < k < j - 1$ , our pointing-based parsing model should learn to assign high scores to the two spans  $(i, k)$  and  $(k + 1, j)$ , or equivalently the pointing decisions  $k \rightarrow i$  and  $k + 1 \rightarrow j$ . However, the pointing formulation described so far omits the trivial self-pointing
decisions, which represent the singleton spans. A singleton span is only created when the splitting decision splits an  $n$ -size span into a single-token span (singleton span) and a sub-span of size  $n - 1$ , i.e., when  $k = i$  or  $k = j - 1$ . For instance, for the parsing process in Figure 2a, the splitting decision at the root span (1, 5) results in a singleton span (1, 1) and a general span (2, 5). For this splitting decision, Eq. 3 requires the scores of (1, 1) and (2, 5). However, the set of pointing decisions  $\mathcal{P}(T)$  does not cover the pointing for (1, 1). This discrepancy can be resolved by modeling the singleton spans separately. To achieve that, we redefine Eq. 3 as follows:
$$
\begin{array}{l} s _ {\text {s p l i t}} (i, k, j) = \\ \left\{\begin{array}{l l}s p (i \rightarrow i) + g p (i + 1 \rightarrow j)&\text {i f} k = i\\g p (j - 1 \rightarrow i) + s p (j \rightarrow j)&\text {i f} k = j - 1\\g p (k \rightarrow i) + g p (k + 1 \rightarrow j)&\text {o t h e r w i s e}\end{array}\right. \tag {5} \\ \end{array}
$$
where  $sp$  and  $gp$  respectively represent the scores for the singleton and general pointing functions (to be defined formally in Section 2.3).
Remark on structural consistency. It is important to note that since the pointing functions are defined to have a global structural property (i.e., the largest span that starts/ends with  $i$ ), our model inherently enforces structural consistency. The pointing formulation of the parsing problem also makes the training process simple and efficient; it allows us to train the model effectively with simple cross entropy loss (see Section 2.4).
Label Assignment. Label assignment of spans is performed after every split decision. Specifically, as we split a span  $(i,j)$  into two sub-spans  $(i,k)$  and  $(k + 1,j)$  which corresponds to the pointing functions of  $k\rightarrow i$  and  $k + 1\rightarrow j$ , we perform the label assignments for the two new sub-spans as
$$
\begin{array}{l} l_{k} = \operatorname *{arg  max}_{l\in L}gc(l|k) \\ l _ {k + 1} = \underset {l \in L} {\arg \max } g c (l | k + 1) \tag {6} \\ \end{array}
$$
where  $gc$  is the label classifier for any general (non-unary) span and  $L$  is the set of possible nonterminal labels. Following Shen et al. (2018), we use a separate classifier  $uc$  for determining the labels of the unary spans, e.g., the first layer of labels NP,  $\varnothing ,\ldots ,\mathrm{NP},\varnothing)$  in Figure 2. Also, note that the label assignment is done based on only the query vector (the encoder state that is used to point).
Figure 2 illustrates the top-down parsing process for our running example. It consists of a sequence of pointing decisions (Figure 2a, top to bottom), which are then trivially converted to the parse tree (Figure 2b). We also provide the pseudocode in Algorithm 2. Specifically, the algorithm finds the best split for the current span  $(i,j)$  using the pointing scores and pushes the newly created sub-spans into the FIFO queue  $\mathcal{Q}$ . The process terminates when there are no more spans to be split. Similar to Stern et al. (2017a), our parsing algorithm has the worst and best case time complexities of  $\mathcal{O}(n^2)$  and  $\mathcal{O}(n\log n)$ , respectively.
2.3 Model Architecture
We now describe the architecture of our parsing model: the sentence encoder, the pointing model and the labeling model.
Sentence Encoder. Given an input sequence of  $n$  words  $\mathbf{X} = (x_{1},\ldots ,x_{n})$ , we first embed each word  $x_{i}$  to its respective vector representation  $e_i$  as:
$$
e _ {i} = e _ {i} ^ {\text {c h a r}} + e _ {i} ^ {\text {w o r d}} + e _ {i} ^ {\text {p o s}} \tag {7}
$$
where  $e_i^{\mathrm{char}}$ ,  $e_i^{\mathrm{word}}$ ,  $e_i^{\mathrm{pos}}$  are respectively the character, word, and part-of-speech (POS) embeddings of the word  $x_i$ . Following Kitaev and Klein (2018), we use a character LSTM to compute the character embedding of a word. We experiment with both randomly initialized and pre
(a) Execution of pointing parsing algorithm
(b) Output parse tree.
Figure 2: Inferring the parse tree for a given sentence and its part-of-speech (POS) tags (predicted by an external POS tagger). Starting with the full sentence span  $(1,5)$  and its label S, we predict split point 1 using the base  $(sp)$  and general  $(gp)$  pointing scores as per Eqn. 3-5. The left singleton span  $(1,1)$  is assigned with a label NP and the right span  $(2,5)$  is assigned with a label  $\varnothing$  using the label classifier  $gc$  as per Eqn. 6. The recursion of splitting and labeling continues until the process reaches a terminal node. The label assignment for the unary spans is done by the uc classifier.
trained word embeddings. If pretrained embeddings are used, the word embedding  $e_i^{\mathrm{word}}$  is the summation of the word's randomly-initialized embedding and the pretrained embedding. The POS embeddings  $(e_i^{\mathrm{pos}})$  are randomly initialized.
The word representations  $(e_i)$  are then passed to a neural network based sequence encoder to obtain their hidden representations. Since our method does not require any specific encoder, one may use any encoder model, such as Bi-LSTM (Hochreiter and Schmidhuber, 1997) or self-attentive encoder (Kitaev and Klein, 2018). In this paper, unless otherwise specified, we use the self-attentive encoder model as our main sequence encoder because of its efficiency with parallel computation. The model is factorized into content and position information in both the self-attention sub-layer and the feedforward layer. Details about this factorization process is provided in Kitaev and Klein (2018).
Pointing and Labeling Models. The results of the aforementioned sequence encoding process are used to compute the pointing and labeling scores. More formally, the encoder network produces a sequence of  $n$  latent vectors  $\mathbf{H} = (h_1, \ldots, h_n)$  for the input sequence  $\mathbf{X} = (x_1, \ldots, x_n)$ . After that, we apply four (4) separate position-wise two-layer Feed-Forward Networks (FFN), formu
lated as  $\mathrm{FFN}(x) = \mathrm{ReLU}(xW_1 + b_1)W_2 + b_2$ , to transform  $\pmb{H}$  into task-specific latent representations for the respective pointing and labeling tasks.
$$
\boldsymbol {h} _ {i} ^ {g p} = \operatorname {F F N} _ {g p} (\boldsymbol {h} _ {i}); \quad \boldsymbol {h} _ {i} ^ {s p} = \operatorname {F F N} _ {s p} (\boldsymbol {h} _ {i}) \tag {8}
$$
$$
\boldsymbol {h} _ {i} ^ {g c} = \mathrm {F F N} _ {g c} (\boldsymbol {h} _ {i}); \quad \boldsymbol {h} _ {i} ^ {u c} = \mathrm {F F N} _ {u c} (\boldsymbol {h} _ {i}) \quad (9)
$$
Note that there is no parameter sharing between  $\mathrm{FFN}_{gp}$ ,  $\mathrm{FFN}_{sp}$ ,  $\mathrm{FFN}_{gc}$  and  $\mathrm{FFN}_{uc}$ . The pointing functions are then modeled as the multinomial (or attention) distributions over the input indices for each input position  $i$  as follows.
$$
g p (i, k) = \frac {\exp \left(\boldsymbol {h} _ {i} ^ {g p} \left(\boldsymbol {h} _ {k} ^ {g p}\right) ^ {T}\right)}{\sum_ {k = 1} ^ {n} \exp \left(\boldsymbol {h} _ {i} ^ {g p} \left(\boldsymbol {h} _ {k} ^ {g p}\right) ^ {T}\right)} \tag {10}
$$
$$
s p (i, k) = \frac {\exp \left(\boldsymbol {h} _ {i} ^ {s p} \left(\boldsymbol {h} _ {k} ^ {s p}\right) ^ {T}\right)}{\sum_ {k = 1} ^ {n} \exp \left(\boldsymbol {h} _ {i} ^ {s p} \left(\boldsymbol {h} _ {k} ^ {s p}\right) ^ {T}\right)} \tag {11}
$$
For label assignment functions, we simply feed the label representations  $\pmb{H}^{gc} = (h_1^{gc},\dots ,h_n^{gc})$  and  $\pmb{H}^{uc} = (h_1^{uc},\dots ,h_n^{uc})$  into the respective softmax classification layers as follows.
$$
g c (l \mid i) = \frac {\exp \left(\boldsymbol {h} _ {i} ^ {g c} \boldsymbol {w} _ {l} ^ {g c}\right)}{\sum_ {l = 1} ^ {| L _ {g} |} \exp \left(\boldsymbol {h} _ {i} ^ {g c} \boldsymbol {w} _ {l} ^ {g c}\right)} \tag {12}
$$
$$
u c (l \mid i) = \frac {\exp \left(\boldsymbol {h} _ {i} ^ {u c} \boldsymbol {w} _ {l} ^ {u c}\right)}{\sum_ {l = 1} ^ {| L _ {u} |} \exp \left(\boldsymbol {h} _ {i} ^ {u c} \boldsymbol {w} _ {l} ^ {u c}\right)} \tag {13}
$$
where  $L_{g}$  and  $L_{u}$  are the set of possible labels for the general and unary spans respectively,  $\pmb{w}_{l}^{gc}$  and  $\pmb{w}_{l}^{uc}$  are the class-specific trainable weight vectors.
We train our parsing model by minimizing the total loss  $\mathcal{L}_{\text{total}}(\theta)$  defined as:
$$
\begin{array}{l} \mathcal {L} _ {\mathrm {t o t a l}} (\theta) = \mathcal {L} _ {g p} \left(\theta_ {e}, \theta_ {g p}\right) + \mathcal {L} _ {s p} \left(\theta_ {e}, \theta_ {s p}\right) \\ + \mathcal {L} _ {g c} \left(\theta_ {e}, \theta_ {g c}\right) + \mathcal {L} _ {u c} \left(\theta_ {e}, \theta_ {u c}\right) \tag {14} \\ \end{array}
$$
where each individual loss is a cross entropy loss computed for the corresponding labeling or pointing task, and  $\theta = \{\theta_{e},\theta_{gp},\theta_{sp},\theta_{gc},\theta_{uc}\}$  represents the overall model parameters; specifically,  $\theta_{e}$  denotes the encoder parameters shared by all components, while  $\theta_{gp},\theta_{sp},\theta_{gc}$  and  $\theta_{uc}$  denote the separate parameters catering for the four pointing and labeling functions,  $gp,sp,gc$  and  $uc$ , respectively.
To show the effectiveness of our approach, we conduct experiments on English and Multilingual parsing tasks. For English, we use the standard Wall Street Journal (WSJ) part of the Penn Treebank (PTB) (Marcus et al., 1993), whereas for multilingual, we experiment with seven (7) different languages from the SPMRL 2013-2014 shared task (Seddah et al., 2013): Basque, French, German, Hungarian, Korean, Polish and Swedish.
For evaluation on PTB, we report the standard labeled precision (LP), labeled recall (LR), and labelled F1 computed by evalb<sup>1</sup>. For the SPMRL datasets, we report labeled F1 and use the same setup in evalb as Kitaev and Klein (2018).
3.1 English (PTB) Experiments
Setup. We follow the standard train-valid/test split, which uses sections 2-21 for training, section 22 for development and section 23 for evaluation. This gives 45K sentences for training, 1,700 sentences for development, and 2,416 sentences for testing. Following previous studies, our model uses POS tags predicted by the Stanford tagger (Toutanova et al., 2003).
For our model, we adopt the self-attention encoder with similar hyperparameter details proposed by Kitaev and Klein (2018). The character embeddings are of 64 dimensions. For general
Model	LR	LP	F1
Top-Down Inference
Stern et al. (2017a)	93.20	90.30	91.80
Shen et al. (2018)	92.00	91.70	91.80
Our Model	92.81	92.75	92.78
CKY/Chart Inference
Gaddy et al. (2018)	-	-	92.10
Kitaev and Klein (2018)	93.20	93.90	93.55
Other Approaches
Gómez and Vilares (2018)	-	-	90.7
Liu and Zhang (2017)	-	-	91.8
Stern et al. (2017b)	92.57	92.56	92.56
Zhou and Zhao (2019)	93.64	93.92	93.78