HC-Search for Incremental Parsing

1 Introduction

Transition-based dependency parsing models the derivation of a parse tree (as illustrated in Figure 1) as a sequence of parsing actions [Nivre, 2008]. Finding the correct tree is transformed into a search-based structured prediction problem [Collins, 2002; Daum´e et al., 2009] of finding the optimal action sequence from an exponentially large search space. The search problem is treated as a left-to-right incremental process, namely, the incremental parsing [Collins and Roark, 2004] and inexact search algorithms like greedy search and beam-search are adopted. Compared with greedy search, beam-search reduces search errors and achieves better performance, especially when guided by a discriminative model learned with structured perceptron algorithm.

The most basic approach to learn such model is via imitation of one oracle action sequence and making corrective updates to enforce the model to score the oracle sequence high. Although empirically performs well, such learning approach faces several problems. One of the problems can be resulted from the intrinsic spurious ambiguity in the transition system [Goldberg and Nivre, 2012], which is, one gold tree can be derived by multiple action sequences. Such ambiguity can confuse the imitation learning process and lead the model to improperly score the "non-oracle but correct"

⇤Email corresponding.

He wrote her a letter

Figure 1: An example dependency parse tree.

action sequence. Another problem is that for each state in the search process, only a partial tree is constructed, while for the final states, information of the tree can be fully recovered. Incremental parsing treats these two different states in the same way and doesn't efficiently use the full tree information, comparing to the global parsing methods like dual-decomposition [Martins et al., 2010] and sampling [Zhang et al., 2014].

Inspired by the recent proposed HC-search [Doppa et al., 2014a], especially its similarity to the incremental parsing in term of loss decomposition, we propose a new method which decomposes the incremental parsing into two steps: H-step and C-step. In the H-step, we perform beam-search to uncover high-quality candidate outputs. In the C-step, we apply a ranking model to select the best loss output. By such decomposition, we are allowed to adopt a relaxed learning objective to learn the incremental parsing model in the H-step and it mitigates improperly scoring problems. We treat search and ranking differently by incorporating global features in the C-step and gain improvement by learning the model with fine grain ranking examples. Contributions of this work fall into the following parts:

• ÷ We follow the loss decomposition in the HC-search framework and decompose the incremental parsing into two steps: H-step for uncovering high-quality candidate outputs and C-step for selecting the best output.
• ÷ We study the problem of adopting a relaxed learning objective to learn the H-step model and it achieves both stage-wise and overall better performance.
• ÷ We also study different ranking examples generation approaches when learning the C-step model and find it necessary to learn from fine grain ranking examples.
• ÷ We conduct our experiments on standard datasets and the results show our method outperforms a strong baseline by an error reduction of 3.63% on English and

Algorithm 1: Beam-search for one step, i.e. BESTk.

Input: x = the input, Bj = list of states in previous step, ~w = the weight, s = the scoring function. 1 B ; 2 for each state c 2 Bj do 3 for each transition action t 2 T do 4 c0 t(c), c0 ▷score c▷score + s(x↪ c0 ↪ ~w) 5 B B [ c0 6 sort B according to the score of each state. 7 return TOP-K(B), k-highest scoring states in B.

Algorithm 2: Learning algorithm for standard incremental parsing.

Input: D = the training instances, R = the max iteration. Output: ~w, The weight for incremental parsing model. 1 ~w0 ~0↪ t 0 . t, the timestamp 2 for r 1▷▷R do 3 for each training instance (x↪ y⇤ ) 2 D do 4 C0▷▷m ORACLEFINDING(y⇤ ) 5 B0 ¶c0♦ 6 for j 1▷▷mdo 7 Bj BESTk(x↪ Bj-1↪ ~wt) 8 if cj ◁2 Bj then 9 C00▷▷j argmaxc02Bj s(x↪C0▷▷c0 ↪ ~wt) 10 ~wt+1 UPDATE(C0▷▷j↪C00▷▷j↪ ~wt) 11 break 12 if cm 6= argmaxc02Bm s(x↪ C0▷▷c0 ↪ ~wt) then 13 C00▷▷m argmaxc02Bm s(x↪C0▷▷c0 ↪ ~wt) 14 ~wt+1 UPDATE(C0▷▷m↪C00▷▷m↪ ~wt) 15 t t + 1 16 return ~w, which is average of ~w0↪ ▷▷↪ ~wt

5.21% on Chinese. Further improvements are achieved when combining two steps together.

We release our code at https://github.com/ExpResults/hcincremental-parsing.

2 Transition-based Incremental Parsing

We follow Nivre [2008] and define the transition-based parsing algorithm as a transition system S = (C↪ T↪ I↪ Ct), where C is a set of states, T is a set of transition actions, I is the initial states and Ct is a set of terminal states. Given a sentence x, parsing is performed by starting from an initial state c0 2 I, and repeatedly applying transition action t 2 T to the current state c 2 C until a terminal state cm 2 Ct is reached. The action sequence C0▷▷m = (c0↪ c1↪ ▷▷↪ cm) is a sequence of states resulted by actions, where c0 2 I, cm 2 Ct, and ti(ci) = ci+1 given ti is the ith step transition action. In this paper, we use the arc-standard algorithm [Nivre, 2008] as our transition system, which has three transition actions: LEFT-ARC (LA), RIGHT-ARC (RA) and SHIFT (SH). 1

The beam-search algorithm is used to derive the best parse tree ˆ y, which searches for the highest scoring action sequence step by step. At each step, the beam-search algorithm keeps a list (i.e. beam) of high-quality states with the guidance of a scoring function and applies transition actions only to the states in beam to result in states for next step, as outlined in Algorithm 1. For a state c, standard incremental parsing parameterizes the scoring function as s(x↪ c↪ ~w) = ~wΦ(x↪ c), where ~w is the parameters and Φ(x↪ c) extracts features from the state. For an action sequence C0▷▷m, such score is Pc2C0▷▷m s(x↪ c↪ ~w).

1 refer to Nivre [2008] for details about the arc-standard system.

The learning and decoding for the incremental parsing are closely related, which decodes the training instance and make corrective updates when search error is made in order to score the gold tree (derived by an oracle action sequence) highest. More specifically, during learning, the algorithm iterates through all the training instances. On each instance (x↪ y⇤ ), the algorithm first generates an oracle action sequence C0▷▷m from y⇤ (the ORACLEFINDING function), then performs beam-search on x to find the highest scoring action sequence C 00▷▷m. If search error is made, which means C 00▷▷m is not identical to C0▷▷m, the algorithmmakes perceptron updates (the UPDATE function) to enforce s(x↪ c↪ ~w) to give a higher score to C0▷▷m (positive sample) than C 00▷▷m (negative sample).

To guarantee the correctness of perceptron updates under approximate beam-search decoding, search errors can be categorized into two types: 1) s(x↪ c↪ ~w) fails to uncover gold tree before search finishes, in which the gold state cj 2 C0▷▷m falls out of the beam Bj at jth step; 2) s(x↪ c↪ ~w) fails to score gold tree highest, in which the gold state cm stays in the final step beam Bm but is not the highest-scored state [Collins and Roark, 2004; Huang et al., 2012]. Figure 2 illustrates these two types of errors. When the first type of error occurs, the beam-search stops and the algorithm updates the parameters with partial sequence pair (C0▷▷j↪C 00▷▷j ). For the second type of error, the algorithm updates with full sequence pair (C0▷▷m↪C 00▷▷m). The learning algorithm is shown in Algorithm 2. Line 8-11 illustrates the condition for the first type of error, and line 12-14 is for the second type of error.

3 HC-search for Incremental Parsing

By reviewing the learning algorithm for standard incremental parsing, we can see that the single scoring function serves two roles: 1) guiding the search process towards the gold tree by minimizing the first type of error and 2) scoring the gold

3.1 HC-search

◦

worst in beam

Figure 3: Example of the learning algorithm for standard incremental parsing being inconsistent in minimizing the two types of errors and improperly punishing the "non-oracle but correct" action sequence. The parse tree in Figure 1 can be derived by 1) the oracle sequence (SH, SH, SH, RA, SH, SH, LA, RA, LA) in solid line and 2) the "non-oracle but correct" sequence (SH, SH, LA, SH, RA, SH, SH, LA, RA) in dashed line. In this case, the second type of error occurs and the learning algorithm updates parameters with 2) as a negative sample which increases the first type of error.

tree as the highest one by minimizing the second type of error. For standard incremental parsing, these two roles are almost consistent with each other because scoring the oracle action sequence highest indicates minimizing both the first and the second type of errors. However, improper punishment on "non-oracle but correct" sequence can be resulted sometimes because spurious ambiguity makes minimizing these two types of errors inconsistent. Figure 3 illustrates this.

Doppa et al. [2014a] studied structured prediction via output space search and proposed the HC-search framework to solve the deficiency of a single scoring function in guiding search and simultaneously ranking generated outputs. Instead of learning a single scoring function, HC-search decomposes the problem into three steps. Step 1 searches for an initial structured output from the input over the primary space [Doppa et al., 2014b]; Step 2 explores a set of alternative outputs rooted at the initial output, which is a search process guided by the heuristic function H over the output space, named as the H-step; Step 3 scores each output with a cost function C and selects the highest scoring one as final output, named as the C-step. To learn H and C, they decomposed the output space search error EHC into two parts: 1) Generation error ✏H due to H not generating high-quality outputs and 2) Selection error ✏C♣H due to C not selecting the best loss output. Given an instance (x↪ y⇤ ), this error is described as

Our method is inspired by the HC-search framework. We find the similarity between standard incremental parsing and HC-search in term of loss decomposition. Following the HC-search, we decompose the errors in standard incremental parsing into 1) Generation error for not generating the gold tree before search finishes, which consists with the first type of error and 2) Selection error for not selecting the best loss tree from the trees in final step beam, which consists with the second type of error. Different from the HC-search which

where y⇤H is the best loss output of those H-step returns. Based on this decomposition, Doppa et al. [2014a] proposed a stage-wised learning method by first training H to minimize ✏H, then training C to minimize ✏C♣H conditioned on ✏H.

performs heuristic search over the output space, we generate our candidate outputs by beam-search, which is guided by a heuristic function H and searches over the primary space (i.e. the space defined by the transition system). More specifically, outputs derived by the sequences in final step beam are collected as the candidate outputs for the C-step. In the C-step, a cost function C is adopted to select the best loss one as the final output. To learn our H and C functions, we follow Doppa et al. [2014a] and minimize ✏H and ✏H♣C in a stage-wised manner.

3.2 Learning Heuristic Function

We parameterize our heuristic function in the same way with standard incremental parsing as H(x↪ y) = Pc2C0▷▷m ~wΦ(x↪ c) where y is derived by C0▷▷m, and H(x↪ y) can be trained similarly by imitating the oracle sequence. However, different from the standard incremental parsing, minimizing the learning objective in our H-step means guiding the search towards the final step and uncovering the gold tree by scoring the oracle sequence higher than the sequences not in beam, but not necessarily scoring it highest. This difference indicates that the second type of error for learning standard incremental parsing model doesn't violate our Hstep learning objective because the gold tree is uncovered in this condition. To learn a better heuristic function, we modify the learning algorithm by omitting the second type of error and only performing corrective updates on the first one. Algorithm 3 outlines this learning algorithm, in which updates on the second type of error (line 12-14 in Algorithm 2) are omitted. By learning the heuristic function in such way, some improper updates like the case in Figure 3 can be voided.

In the learning algorithm for standard incremental parsing, making corrective updates with the "highest scoring incorrect" sequence as a negative sample C 00▷▷m will learn a model that gives the oracle sequence C0▷▷m the highest score. While, without the necessity of scoring C0▷▷m highest in our H-step, we are allowed to select any sequence in beam as a negative sample, because updates with any of these sequences C 00▷▷m as a negative sample will enforce the model to score C0▷▷m higher than C 00▷▷m and uncover the gold tree derived by C0▷▷m in the outputs. In Algorithm 3, we generalize the negative sample selection into a SELECTNEGATIVESAMPLE function (line 9). In this paper, we investigate two different strategies for selecting negative sample, which are 1) BEST by selecting the highest scoring sequence in beam and 2) WORST by selecting the lowest scoring sequence. Both these two strategies satisfy our learning objective, but lead to different models. Intuitively, the WORST strategy is more conservative than the BEST because it only encourages the model to score the oracle sequence higher than all the sequences not in beam.

3.3 Learning Cost Function

Given a set of H-step outputs YH(x), we want our cost function correctly rank the "best loss" output in the C-step. We formulate the learning problem for the cost function as a ranking problem. More specifically, we want the "better loss" outputs to rank better than the "worse loss" ones, which is a bipartite ranking problem [Agarwal and Roth, 2005]. In general, our learning algorithm for the cost function firstly generates a collection of bipartite ranking examples, then learns parameters from these examples.

A widely used approach [Huang, 2008; Doppa et al., 2014a] for generating the ranking examples is by collecting the "best loss" outputs from YH(x) as Ybest and generating the examples as (y+↪ y-) 2 Ybest ⇥YH(x) ∩Ybest. Owing to that it categorizes the outputs into the "best loss" and "nonbest loss" groups and only cares for the ranks between these two groups with omitting the ranks among the "non-best loss" outputs, we name it as COARSE approach.

To make use of ranks among the "non-best loss" outputs and refine the COARSE approach, we categorize the outputs into m groups (YH↪1↪ ▷▷↪ YH↪m) by their losses to the gold tree. Outputs in the same group share the same loss and higher ranked group has better loss than the lower ranked. Thus, YH↪1 is equivalent to Ybest in the COARSE approach. For the jthe group YH↪j, we collect all its lower ranked outputs [mk=j+1YH↪k and generate the ranking examples as (y+↪ y-) 2 YH↪j ⇥ [mk=j+1YH↪k. By generating examples with FINE grain approach, we allow our model to capture the sophisticated relation between outputs of different qualities.

In this paper, we parameterize our cost function as C(x↪ y) = ~wΦ(x↪ y), where Φ(x↪ y) extracts features from an output tree y at arbitrary order. For a pair-wised ranking example (y+↪ y-), we learn the parameters ~w by constraining C to score y+ higher than y-, i.e. C(x↪ y+) > C(x↪ y-). Further, we require that C(x↪ y+) is greater than C(x↪ y-) by a margin ∆(y+↪ y-) = L(x↪ y-↪ y⇤ ) - L(x↪ y+↪ y⇤ ). By imposing the margin, we enforce our cost function to score the tree far from "best loss" tree even smaller.

Learning from every pair of ranking examples between "better loss" group Y + and "worse loss" group Y - can result in an over-constrained problem. In this case, we relax the constraint by enforcing C(x↪ y) to give the lowest-scored output in Y + a higher score than the highest-scored output in

Input: D = the training instances, R = the max iteration. Output: ~w, The weight for the cost function. 1 G ; . G, a set of ranking group pairs 2 for each training instance (x↪ y⇤ ↪ YH(x)) 2 D do 3 YH↪1↪ ▷▷↪ YH↪m RANK(x↪ y⇤ ↪ YH(x)) 4 for j 1▷▷m-1 do 5 G G [ (x↪ y⇤ ↪ YH↪j↪ [mk=j+1YH↪k) 6 ~w0 ~0, t 0 7 for r 1▷▷R do 8 for each ranking group pair (x↪ y⇤ ↪ Y +H↪ Y - H ) 2 G do 9 y+ argminy2Y+H ~wtΦ(x↪ y) 10 y- argmaxy2Y-H ~wtΦ(x↪ y) 11 rf ~wtΦ(x↪ y+) - ~wtΦ(x↪ y-) 12 ∆ L(x(i) ↪ y-↪ y⇤ ) -L(x(i) ↪ y+↪ y⇤ ) 13 if ∆ 6= 0 and rf < ∆ then 14 ~wt+1 UPDATEPA(rf↪∆↪ ~wt) 15 t t + 1 16 return ~w, which is average of ~w0↪ ▷▷↪ ~wt

Y -. Putting them together, we formulate our constraint as

We outline our learning method for the cost function in Algorithm 4. Line 1-5 shows the ranking example generation approach. The categorizing part of COARSE and FINE approaches is generalized into a RANK function. Line 615 shows the model learning procedure. We use the online passive-aggressive algorithm [Crammer et al., 2006] to learn the parameters ~w. For each pair of bipartite ranking groups, lowest-scored "better loss" output y+ and highestscored "worst loss" output y- are picked out (line 9, 10). If C(x↪ y) fails to score y+ higher than the y- by ∆(y+↪ y-), passive-aggressive updates are performed (line 14).

Cross Validation

We need to note that mis-matched output distribution between training and testing will be resulted if we generate the ranking examples for learning the cost function on the data we train our heuristic function. To mitigate this problem, ranking examples are generated via cross validation.

4 Experiment

4.1 Settings

We conduct our experiments on the Penn WSJ Treebank (PTB) for English and Chinese Treebank 5 (CTB5) for Chinese. Data are split into training, development and test set in the same way with the previous study [Zhang and Nivre, 2011]. Bracket sentences in PTB are converted to dependency formats with Penn2Malt. 2 For those in CTB, headfinding rules from Zhang and Nivre [2011] are used. For the English data, automatically assigned POS tags are obtained using 10-fold jackknifing with an accuracy of 97.17, 97.19 and 97.31 on training, development and test set. For the Chinese data, gold segmentation and POS tags are used. Parsing performance is measured by unlabeled attachment score (UAS) excluding punctuations. 3

2 http://stp.lingfil.uu.se/⇠nivre/research/Penn2Malt.html

We set the beam size to 64 for both training and testing in the H-step, thus, the size of the candidate outputs is 64 for each instance in the C-step. During training our cost function with cross validation, we set the number of folds as 20. Best iterations for learning our heuristic and cost functions are tuned on the development set. Hamming distance is used as loss function L throughout this paper.

In the H-step, we adopt the feature templates used in Zhang and Nivre [2011] to capture information on each search state. Zhang et al. [2014] proposed rich global features for their sampling-based parser and we adopt their feature templates in the C-step. Details for the feature templates can be referred in the supplemental materials.

4.2 Baseline

Our BASELINE parser is a standard incremental parser with the same feature templates and beam size to our H-step. On the PTB and CTB5 test set, our BASELINE parser achieves UAS scores of 92.48 and 86.44 respectively. Since the PTB score is higher than its transition-based counterparts in Table 4, we can confirm our BASELINE parser as a strong one.

4.3 Results

Table 1 shows our results. We report the performances of our parsers combining of different negative sample selection strategies in learning the heuristic function and different ranking example generation approaches in learning the cost function. Our best-setting parsers outperform the BASELINE by 0.28 on PTB and 0.71 on CTB5 test data and the error reductions are 3.63% and 5.21% respectively. Significance test shows the improvements are statistically significant with p < 0▷01.

A natural question raises that "Can we achieve similar improvement by adding an additional ranking step (i.e. the Cstep) over our BASELINE?" We replace the heuristic function in the BEST+FINE parser with our BASELINE and perform the same ranking process on the BASELINE outputs. We show the result in the last block of Table 1. From this result, improvements over the BASELINE are observed, but they are of a smaller margin than the best-setting parsers.

3 Following Chen and Manning [2014], a token is a punctuation if its gold POS tag is ¶" " : , .♦ for English and PU for Chinese.

4.4 Loss Decomposition Analysis

We analyze the decomposed loss (the Generation loss ✏H and the Selection loss ✏C♣H) on the development set to investigate the reason for improvements. Given a set of H-step outputs YH(x), according to Equation 1, ✏H is resulted by the heuristic function losing gold tree and is measured by L(x↪ y⇤H↪ y⇤ ), which is the number of errors between the best loss output y⇤H in YH(x) and the gold tree y⇤ . ✏C♣H is resulted by the cost function not selecting the best loss output and is measured by the average number of errors between the final output ˆ y and the best loss outputs Ybest, which is Py2Ybest L(x↪ ˆ y↪ y) ◁ ♣♣Ybest♣♣.

Table 2 shows the loss decomposition analysis results. For the H-step, the parsers with relaxed learning objective (BEST, WORST) generally achieve smaller ✏H than the BASELINE. And the parsers with conservative SELECTNEGATIVESAMPLE strategy (i.e. the WORST) achieve consistently smaller loss than those with aggressive strategy (i.e. the BEST). This table shows the relaxed learning objective is more helpful for uncovering high-quality outputs in the H-step. We attribute the smaller loss to the fact that the relaxed learning objective mitigates improper updates resulted from search ambiguities. Our observation of the conservative strategy achieving better ✏H also confirms that. For the C-step, the parsers with FINE grain approach consistently achieve better ✏C♣H than those with COARSE approach. This shows the necessity to learn from fine grain ranking examples.

In Table 2, we can see that a smaller ✏H always couples with a larger ✏C♣H. It's difficult to confirm which step contributes more to the final performance because our C-step error is effected by the H-step outputs. But by comparing the BEST+FINE, WORST+FINE with BASELINE+FINE, the parsers trained with relaxed learning objective achieve better overall performance, which indicates the importance to learn the model according to the loss decomposition rather than minimizing ✏C♣H on both steps like the BASELINE+FINE.

4.5 Mixing H and C functions

Following many approaches that mix scores from two stages [Hayashi et al., 2013; Le and Zuidema, 2014], we define our mixture parser as a combination of our H and C functions with a linear interpolation, i.e. ˆ y = argmaxy2YH(x)↵H0 (x↪ y) + (1-↵)C 0 (x↪ y), where H0 (x↪ y) and C 0 (x↪ y) are the rescaled scores and ↵ 2 [0↪ 1] is a hyper parameter tuned on the development set. 4 We compare our mixture and non-mixture parsers in Table 3. Our mixture parsers outperforms the nonmixture counterparts by 0.26 and 0.32 on BEST+FINE and WORST+FINE. The gains in UAS score suggest that our method can be further improved by considering the quality of heuristic search in the final decision. Also, our BEST+FINE and WORST+FINE mixture parsers perform better than the BASELINE+FINE mixture parser, which further shows the effectiveness of the relaxed learning objective in the H-step and the necessity to learn the model based on the decomposed loss.

Finally, we compare our best-setting parser with the state-of-the-art parsers in Table 4. Our mixture parser gets superior accuracy than the transition-based parsers and achieves comparable performance with the state-of-the-art dual-decomposition and mixture-model parsers.

4 In this paper, we rescale the H(x↪ y) and C(x↪ y) over YH(x) as F 0 (x↪ y) = F(x↪y)-miny0 F(x↪y0 ) maxy0 F(x↪y0)-miny0 (x↪y0) . ↵ is 0.395 for BASELINE+FINE, 0.210 for BEST+FINE and 0.225 for WORST+FINE in our experiments.

4.6 Parsing Speed

One advantage of incremental parsing lies on the property that parsing is bounded to linear time. Outputting k-best candidates can be done without increasing the time-complexity compared to the exact search algorithm based on dynamic programming [McDonald and Pereira, 2006]. In our approach, only an additional ranking model is imposed to score and select the best loss output from a fix-sized set of outputs, thus, it maintains the linear complexity. Empirically, we show the relative time consumption of our HC-search parsers compared with the BASELINE in Table 1. This comparison shows that our parsers can perform accurate parsing without sacrificing the speed.

5 RelatedWork

Previous studies on standard incremental parsing mainly focus on proposing new transition systems, speeding up decoding and incorporating global features [Huang and Sagae, 2010; Zhang and Nivre, 2011; Bohnet and Nivre, 2012]. In this paper, we study the model learning in stage-wised manner based on loss decomposition.

Two-stage parsing methods are widely adopted. One genre of such work is performing reranking on a k-best list [Collins and Duffy, 2002; Charniak and Johnson, 2005; Huang, 2008; Le and Zuidema, 2014]. Another genre is doing a secondtime decoding with the first stage output as features [Hayashi et al., 2013]. Our method can be viewed as a rerankingstyled method. However we analyzed the theoretical intuition for our two-stage method and learn our model following loss decomposition, which shows superior to the model without following such decomposition. What's more, we learn the ranking model from fine grain ranking examples which is less studied in previous works.

Zhang et al. [2014] proposed a sampling-based inference method for dependency parsing, which can be considered as an instance of the output space search. Our work resembles theirs by incorporating global features in the C-step, but differs in both decoding and model learning.

In this paper, we base our method on the framework of HC-search [Doppa et al., 2014a], but we employ a different H-step. In their work, heuristic search is performed on the output space while ours is performed on the primary space (i.e. the space defined by the transition system). We show that primary space search can also be effective for generating high-quality outputs.

6 Conclusion

In this paper, we proposed a new approach for incremental parsing based on the loss decomposition of HC-search framework. In the H-step, we uncover high-quality candidate outputs with beam-search. In the C-step, we select the best loss output with a ranking model. We learn the H-step model with a relaxed objective and the C-step model from fine grain ranking examples. Experimental results show our parser outperforms a strong baseline. Further improvements are achieved when combining two steps together.

Acknowledgments

This work was supported by the National Key Basic Research Program of China via grant 2014CB340503 and the National Natural Science Foundation of China (NSFC) via grant 61133012 and 61370164.