VRCA: A Clustering Algorithm for Massive Amount of Texts

1 Introduction

Facing the large-scale texts in the web, it is difficult for users to manually dig useful information from websites. This situation forces many text based analysis tools to appear. In general, clustering is a popular tool for text analysis due to its unsupervised characteristic. Unfortunately, most of traditional clustering algorithms can only handle small-scale text collection. They lose their high performances on large-scale text collection. The reason to this situation mostly attributes to the fact that most of traditional clustering algorithms apply vector space model to organize texts and clusters. When text collection is small, this model is all right, whereas when it enlarges, vector space model will generate high-dimensional and sparse vectors. This kind of vectors brings in three problems. The first is that the weights of many entries are close to zero, which depresses performance as indicated by [Xu and Wunsch, 2005]. The second is that many useless features are adopted to represent cluster. The last is that highdimensional vectors make similarity calculation expensive.

To cluster large-scale text collection efficiently, this paper proposes a vector reconstruction based clustering algorithm, abbreviated as VRCA, where cluster's vector is formed by only choosing a few features that are useful to represent cluster. Two alternately repeated sub-processes are carried out for this purpose. In one sub-process, feature's weight is fine-tuned to gradually reduce one predefined optimization function via iterative tuning process. In the other sub-process, two measures, respectively measuring cluster's intra agglomeration and cluster's inter distinctness, are calculated, and the useful features that are not only capable to represent one cluster but also capable to separate different clusters apart are chosen to reconstruct cluster's vector.

Two large-scale text collections, ClueWeb9 and TRC2, are adopted to test the performance of our algorithm. Besides, another two popular text collections (Reuters and Newsgroup) are also adopted to prove our algorithm's high performance on small-scale text collection.

2 Related Work

Until now, many text clustering algorithms have been proposed. They can be partitioned into five categories: a) partition based; b) density based; c) hierarchy based; d) grid based; e) model based. K-means [MacQueen, 1967], DBSCAN [Martin et al., 1996], BIRCH [Zhang et al., 1996], STING [Wang et al., 1997], Neuron Network [Kohonen et al., 2000] are their typical exemplars. To further improve clustering performance, some algorithms are even derived from the other subjects, such as Spectral Clustering from Physics [Cai et al., 2008], Non-Regression Matrix Factorization from Mathematics [Wang et al., 2007], LDCC based on Latent Dirichlet Allocation from Topic Models [Shafiei and Milios, 2006]. Nevertheless, to our best knowledge, though it has been proposed so many clustering algorithms, the organization model applied by them seldom changes. That is vector space model. It will generate high-dimensional and sparse vectors in the situation that text collection becomes too large. Therefore, this model makes traditional clustering algorithms fail to cluster large-scale text collection. For this reason, many ways are designed to improve this model. The most popular ones are feature selection and dimension reduction.

For feature selection, it is often conducted to preserve the features that are useful for separating input texts apart. Liu et al., [2013] applied probability model to choose features. Zhao et al., [2010] added an entropy based choosing process for further filtering useless features. With time passing, more and more plans are proposed, e.g. mutual information based in [Kwak and Choi, 2002], correlation parameter based in [Sakar and Kursun, 2012]. The common point shared by them is that they treat feature selection as the preprocessing step of clustering. The two processes (selection and clustering) run for two distinct objectives.

For dimension reduction, it is often conducted to cut down vectors from high dimension to low dimension. Latent semantic indexing (LSI) proposed by Todd and Michael [1997] is one of the most prevalent methods, whereas the defect of it is that the features in the reduced vector lose their semantic meanings. Another powerful tool is principal component analysis (PCA) utilized in graph processing. Gomez and Moens [2012] imported it in text classification and obtained high performance. Unfortunately, the same issue happens to them as to the methods for feature selection, that is, the two processes (reduction and clustering) are isolated from each other. Thus, the way that treats clustering and dimension reduction or feature selection as two isolated processes does not definitely obtain prominent results.

Aiming at solving the drawbacks of traditional algorithms, this paper proposes an algorithm by combing vector reconstruction and text clustering together.

3 Clustering Process of VRCA

Due to its simple structure, vector space model is extensively used to organize texts and clusters as vectors. For simplicity, this model is also used in our algorithm. However, this model imports many useless features and depresses clustering performance very much. Therefore, if we can define a threshold, and only choose features that are useful to represent cluster to reconstruct cluster's vector, clustering performance should be improved. Our algorithm designs two processes to achieve this goal. In detail, text clustering is conducted in partial tuning sub-process, where texts are partitioned into clusters to reduce one predefined optimization function, and cluster's vector is reconstructed in overall tuning sub-process, where no more than three hundred features that are useful to represent cluster are chosen to reconstruct cluster's vector.

3.1 Partial Tuning Sub-Process

In this sub-process, texts are partitioned into clusters to reduce one predefined optimization function as

in which D denotes text collection and dj denotes one text in D; C denotes cluster set and ci denotes one cluster in C; Vdj denotes the text vector of dj and Vci denotes the cluster's vector of ci; v denotes vector dimension; Vdj(l) and Vni(l) denote the weights of lth entry in Vdj and in Vci. Eq.1 is extensively used to control clustering process. As indicated later that our algorithm employs iterative tuning process from self-organizing-mapping (SOM) algorithms to partition texts, we also adopt the convergence condition used in [Alahakoon et al., 2000] to stop our clustering algorithm. That condition is when the difference between two values obtained by Eq.1 through two successive steps falls below 0.0001, cluster partitions obtained by these two successive steps are very close. Then, we can stop clustering algorithm.

As indicated in [Kohonen et al., 2000], in SOM algorithms, neuron can be seen as cluster's center (in vector space model, cluster's center is represented by vector, so it is also called cluster's vector). This kind of algorithms organizes neuron (or cluster's vector) into topology, and via its iterative tuning process, neurons (or clusters) are partitioned well and one neuron is more similar to its adjacent neurons than to the other neurons. This characteristic is similar to neuron in human's brain. Therefore, in SOM, cluster's vector is called neuron. In our algorithm, we just borrow the iterative tuning process from SOM algorithms to fine-tune cluster partition. However, traditional SOM algorithms employ concurrence based similarity measurements to calculate similarity between text and neuron, and also never consider removing useless features. Therefore, their performances are lower than our algorithm (VRCA), which can be clearly seen from experimental results (Table 2 and Table 3).

In text clustering, it is difficult to predefine cluster number. Therefore, we employ the method used in [Andreas et al., 2002]. If convergence condition is not met after running iterative tuning process once, each neuron's cohesion is then measured by Eq.2 and one neuron will be created by Eq.3 to make cluster partition approach to convergence condition.

in which ni denotes the neuron corresponding to the cluster ci; Vni denotes the neuron vector of ni ; it is also the cluster's vector of ci; dj denotes one text included by the cluster ci.

After measuring neuron's cohesion, the neuron of the least cohesion (ne) and its one neighbor (nd) are chosen to create one new neuron (nr) as � �

in which Vnr(l) is the mean between Vne(l) and Vnd(l).

Traditional SOM algorithms apply concurrence based similarity measurements to calculate similarity between text and neuron. In this kind of measurements, similarity result is affected by each feature's weight. However, in text clustering, the features that can better represent the topic of one cluster are really useful in similarity calculation. The other features not only prolong running time but also depress clustering performance. Due to this reason, we use intersection between text and neuron to measure similarity between them. In this measurement, only the intersected features that are assigned to non-zero weights in both text vector and neuron vector are considered as

in which ni denotes ith neuron in neuron set; dj denotes jth text in text collection; fl denotes lth feature and resides at lth entry; Vni denotes the neuron vector formed from ni; Vdj denotes the text vector formed from dj; Vdj(l) denotes the weight of lth entry in Vdj, evaluated by TF-IDF; Vni(l) denotes the weight of lth entry in Vni, updated by Eq.5; r denotes the quantity of non-zero entries between Vdj and Vni; q and p denote the quantities of non-zero entries in Vdj and in Vni.

In overall tuning sub-process (Section 3.2), our algorithm uses two measures to weigh features and assigns the features that are capable to represent the topic of one cluster to nonzero weights. If many features are of non-zero weights in one text vector and one neuron vector, it indicates that the text and the neuron share the similar topic. They may be similar at a high probability. Eq.4 just forms according to this idea.

As shown in Eq.4, the number of entries needed to be scanned by our similarity measurement equals to max(q,p). It means that time complexity of Eq.4 is O(max(q,p)). For q, it is quite small, since each text has few features among vector space. For p, if it is also small, our measurement will own high running speed. Fortunately, via the threshold that is set to limit the quantity of non-zero entries in overall tuning subprocess introduced in Section 3.2, the characteristic of neuron vector generated by our algorithm is sparseness.

To apply iterative tuning process of SOM, we need to tune feature's weight in neuron vector. Because our algorithm replaces concurrence based similarity measurement by intersection based similarity measurement, its neuron adjustment function also needs to be changed as

in which Vni(l)(t+1) and Vni(l)(t) are the weights of the feature fl in neuron vector Vni after and before neuron adjustment; a(t) denotes learning rate and descends along with tuning process; dist and NH(t) denote distance function and neighborhood range, which form the adjusting range. The neurons in that range all need to be adjusted [Alahakoon et al., 2000].

For Eq.5, if two weights of one feature (e.g. fl) are both non-zero in two vectors formed from one text and one neuron (e.g. dj and ni), the upper sub-equation is applied to adjust the weight of fl in ni. It lets the neuron ni approach to the text dj. Because our algorithm reconstructs cluster's vector, many features are assigned to zero weights. Then, it is easy to occur that some features' weights are non-zero in text vector and zero in neuron (or cluster's) vector. These features are assigned to an initial weight by the lower sub-equation.

3.2 Overall Tuning Sub-Process

In partial tuning sub-process, neuron vector is tuned by an iterative tuning process. However, this process may bring in some features that are useless to represent cluster. To remove them, our algorithm adds an overall tuning sub-process.

In text clustering, the quantity of features that are capable to represent the topic of one cluster is much smaller than the dimension of vector space [Hammouda and Kamel, 2004]. For example, if there is one cluster whose topic is about "sport", to represent it, it only needs the features whose meanings are relevant to "sport". Thus, we can define a threshold to limit the number of features in cluster's vector to represent this cluster. Based on the analysis in [Martin et al., 2004; Liu et al., 2014] and our experimental results (Figure 1 and Table 1), this threshold is no more than 300.

Since partial tuning sub-process may bring in some features that are useless to represent cluster, we design two measures to weigh feature's ability as shown in Eq.6 and Eq.8. These two equations respectively measure feature's ability to represent one cluster and the ability to separate one cluster from the others. The features of less ability will be assigned to zero weights to be removed from cluster's vector.

Feature's intra-cluster representative ability is measured by Eq.6 to show how one feature can represent one cluster. In other words, this ability stands for feature's capacity to aggregate similar texts into a compact cluster.

in which ci denotes one text cluster, which includes the texts that are more similar to the neuron ni than to the other neurons; |ci| denotes the amount of texts included by ci. The other symbols are already explained in Eq.1.

There are two parts in Eq.6 separated by a plus. The left part is calculated based on the fact that if one feature (e.g. fl) is assigned to similar weights among the texts included by one cluster (e.g. ci), fl can help aggregate similar texts into ci. For the right part, since our algorithm is just based on traditional SOM algorithms, neuron in our algorithm also represents cluster's center. Then, if the weight of fl in each text included by ci is similar to the weight of fl in ni, fl can help assemble similar texts around the center of ci.

In fact, if one feature has larger intra-cluster representative ability, it will be assigned to smaller value by Eq.6. Thus, Eq.6 is reversed to

The equation used to measure feature's inter-cluster discriminable ability to separate one cluster from the others is shown as

in which k denotes the quantity of neurons.

In traditional SOM algorithms, the weight of one feature in one neuron vector is the mean weight of that feature among the texts mapped to that neuron [Kohonen et al., 2000]. Since our algorithm employs iterative tuning process from SOM algorithms, our algorithm also obeys this principle. Then, if one feature has distinct weights among most of neuron vectors, this feature can help separate clusters apart. Eq.8 just forms according to this idea.

3.3 Algorithm Workflow and Related Analyses

Algorithm Workflow

Input: text set D; maximum neuron (or cluster) number k; current neuron (or cluster) number ck; convergence condition maxth; iterative index t; the quantity of steps to enter into overall tuning sub-process maxt; the threshold to limit the selected features maxp. Output: neuron (or cluster) set N (or C, in our algorithm, one neuron

corresponds to one cluster).

Initialization:

1. Initialize t=0;
2. Select ink random texts from D, ink<<k, and treat these ink texts as ink initial neurons;
3. ck=ink.

Partial Tuning Sub-Process:

1. Select one random text dj from D;
2. Use Eq.4 to calculate similarity between dj and each neuron in N;
3. Select the neuron with the maximum similarity, and mark it as ni;
4. Use Eq.5 to adjust ni and its adjacent neurons in N;
5. Check whether the difference between two values obtained by Eq.1 at step t and step t-1 is below maxth or not; if yes, stop;
6. Calculate the cohesion of each neuron by Eq.2;
7. Select the neuron that has the least cohesion, and mark it as ne;
8. Select the neuron that has the least cohesion in the neighbors of
9. ne, and mark it as nd;
10. Insert one new neuron between ne and nd by Eq.3;
11. ck=ck+1;
12. Check whether ck is larger than k or not, if yes stop.
13. t=t+1;
14. Check whether t is the integral times of maxt or not; if yes, go to step 17 to enter into overall tuning sub-process; else, go to step 4.

Overall Tuning Sub-Process:

For each neuron ni

For each feature fl in ni

1. Use Eq.7 to measure intra-cluster representative ability of fl;
2. Use Eq.8 to measure inter-cluster discriminable ability of fl;
3. Add these two abilities together;

End For

End For

1. Sort features in terms of their abilities, and choose maxp features of larger abilities to reconstruct cluster's vector.
2. Go to step 4 to enter into partial tuning sub-process.

Parameter Setting

The previous workflow has five initial parameters needed to be fixed in advance. They are k, ink, maxth, maxt, maxp.

For k, it denotes the maximum cluster number. We set it as the square root of n. As indicated in [Liang et al., 2012], cluster number is often smaller than the square root of the size of text set. When k exceeds this number, cluster partition becomes incredible. We can stop clustering process. For ink, it denotes the initial neuron number. We set it as 2 without loss of generality. For maxth and maxt, they respectively denote convergence condition and the quantity of steps during partial tuning sub-process. We set them according to the parameter setting in [Alahakoon et al., 2000]. The reason is that our algorithm is just based on SOM. Then, we can borrow the parameter setting from SOM algorithms. Besides, as stated in [Alahakoon et al., 2000], the setting on maxth and maxt does not deeply affect clustering results. For maxp, it denotes the threshold to limit the number of selected features to reconstruct cluster's vector. We set it as 300 according to the analysis in [Martin et al., 2004; Liu et al., 2014] and our experimental results in Section 4.1 (Figure 1 and Table 1).

Time Complexity

The workflow is partitioned into three parts: initialization, partial tuning sub-process, and overall tuning sub-process.

With respect to initialization, time complexity of steps 1, 3 is O(1); time complexity of 2 is O(ink); because ink is much smaller than k, time complexity of 2 is at most O(k). Therefore, time complexity of initialization is O(1+k)=O(k).

With respect to partial tuning sub-process, time complexity of steps 4, 12 to 16 is O(1); time complexity of 5, 7 is O(kmax(maxq,maxp)), in which maxq denotes the maximum quantity of non-zero entries in text vector, maxp denotes the maximum number of selected features to reconstruct cluster's vector; because text vector is inevitably sparse, maxp is often larger than maxq; then, O(kmax(maxp,maxq)) equals to O(kmaxp); time complexity of 8, 9 is O(knmaxp); time complexity of 6, 10 is O(ck); since ck<k, time complexity of 6, 10 is at most O(k); time complexity of 11 is O(nb), in which nb denotes the number of neighbors around one neuron; because nb is also smaller than k, time complexity of 11 is at most O(k). Therefore, time complexity of partial tuning subprocess is O(1+k+kmaxp+knmaxp)=O(knmaxp).

With respect to overall tuning sub-process, time complexity of step 17 is O(maxci), in which maxci denotes the maximum quantity of texts included by one cluster (e.g. ci); since maxci<n, time complexity of 17 is at most O(n); time complexity of 18 is O(k); since k<n (cluster number k is smaller than the size of text set n), time complexity of 18 is at most O(n); time complexity of 19 is O(1); these three steps roll for O(kmaxp) times; then, time complexity of this loop is O(knmaxp); step 20 is ranking step, thus time complexity of it is O(maxplogmaxp); time complexity of step 21 is O(1). Therefore, time complexity of overall tuning sub-process is O(knmaxp+maxplogmaxp+1)=O(knmaxp+maxplogmaxp).

In conclusion, for initialization, it only needs to run once; for partial tuning sub-process, supposing that it runs for about l times to converge, then for overall tuning sub-process, it runs for l/maxt times. Thereby, the total time complexity is O(k+l*(knmaxp)+l/maxt*(knmaxp+maxplogmaxp))=O(klnmaxp+ (lmaxplogmaxp)/maxt).

Taking traditional efficient clustering algorithms, such as K-means, GSOM, and GHSOM (their high-speed abilities can be seen from Table 3), for comparison, their time complexity is linear, O(klnmaxp) [Shahpurkar and Sundareshan, 2004]. The differences between them and our algorithm are two points. One is that maxp in our algorithm is quite smaller than that in them, since our algorithm limits the number of selected features. The other is that our algorithm has an additional part, O(lmaxplogmaxp). However, because maxp in our algorithm is set as constant, this part can be neglected. Due to these two reasons, our algorithm should possess higher running velocity than traditional clustering algorithms, which can also be observed from experimental results (Table 3).

4 Experiments and Analyses

The following experiments are partitioned into three parts. The first part discusses how to set threshold (denoted as maxp) to choose features to reconstruct cluster's vector. The second and the third parts are conducted to compare our algorithm with several popular baseline algorithms in time performance and clustering precision to demonstrate our algorithm's high quality. The baseline algorithms include K-means, STING, DBSCAN, BIRCH, GSOM, GHSOM, Spectral Clustering, Non-Regression Matrix Factorization (NRMF), and LDCC. Four testing collections are employed in the experiments, including two prevalent testing collections, Reuters (21,578) and Newsgroup (2,000), and two large-scale text collections, TRC2 (1.8 millions), and released ClueWeb9 after removing empty and short texts (100 millions).

In order to compare the precisions of different algorithms, two metrics are employed. They are NMI (Normalized Mutual Information) and ARI (Adjusted Random Index) respectively introduced in [Zhao and Karypis, 2002] and [Hubert and Arabie, 1985].

NMI is calculated in Eq.9. It is calculated based on entropy. Due to the reason that NMI does not need to predefine cluster number and utilizes inter-cluster distinctness and intracluster agglomeration to measure clustering precision, it is extensively applied in clustering evaluation scenario.

in which Sr denotes rth cluster obtained by clustering algorithm; nr denotes the quantity of texts included by Sr; Cq denotes qth cluster predefined by user; n q denotes the quantity of texts included by Cq; n q r denotes the quantity of texts included by the intersection between Sr and Cq; n denotes set size; k denotes cluster number.

Different from NMI that needs to relate the labels indicating the clusters obtained by clustering algorithm to the labels predefined by user, ARI frees from predefining cluster partition. It combines two texts as one pair-point, and uses four situations to identify clustering results:

a) Two texts in one pair-point are manually labeled in the same cluster, and in clustering results they are also in the same cluster. b) Two texts in one pair-point are manually labeled in the same cluster, and in clustering results they are in different clusters. c) Two texts in one pair-point are manually labeled in different clusters, and in clustering results they are also in different clusters. d) Two texts in one pair-point are manually labeled in different clusters, and in clustering results they are in the same cluster.

Apparently, a and c stand for the rightly partitioned pairpoints, and can be used to measure clustering precision as

4.1 The Number of Selected Features

In our algorithm, we need to set a threshold, labeled as maxp, and choose features less than maxp to reconstruct cluster's vector. Figure 1 shows how maxp affects clustering precision on the four testing collections. For clarity, Table 1 shows the value of maxp when precision in Figure 1 becomes stable.

One phenomenon can be observed from Figure 1. That is all the precision curves in Figure 1 own the same track. They all climb along with the increase of maxp at the beginning, and when maxp is beyond certain value (a little smaller than 300) they become stable. The reason to this phenomenon is that in our algorithm, we measure features via their abilities to represent cluster. When we increase the number of selected features (maxp), more useful features will be imported to reconstruct cluster's vector and therefore increase clustering precision. However, when this number exceeds certain value, the imported features are useless to represent cluster. Fortunately, in our algorithm, the useless features will be assigned to zero weights. Therefore, precision curves become stable, but importing many useless features obviously prolongs running time. By combining Figure 1 and Table 1, it can be observed that when clustering precision becomes stable, different collections correspond to similar maxp. Among these four collections, the size of TRC2 is about one thousand times of the size of Newsgroup, while maxp on them is very close. The reason to this phenomenon is that the texts included by one cluster should reflect one similar topic. Then, only the semantically similar features that are related to the topic are really useful to represent this cluster. The number of those semantically similar features only occupies a small proportion of vector space, and does not increase much when text collection enlarges. Based on Table 1 and several previous literatures [Martin et al., 2004; Liu et al., 2014], this number seldom exceeds 300. Therefore, we set maxp as 300 to be the threshold to limit the number of selected features to reconstruct cluster's vector.

4.2 Clustering Precision

We record clustering precisions of different algorithms measured by NMI and ARI on Reuters, Newsgroup, ClueWeb9, and TRC2 in Table 2.

By observing Table 2, one conclusion can be drawn. That is clustering precisions of VRCA on small-scale and largescale text collections are both outstanding, while the other clustering algorithms all fail to cluster large-scale text collection. They cannot copy their high quality from small-scale text collection to large-scale text collection. Due to space transition executed by SOM, clustering precisions of GSOM and GHSOM do not drop greatly on large-scale text collection. Besides, together with dimension reduction, Spectral Clustering, NRMF, and LDCC can achieve much higher precisions than GSOM and GHSOM. Nevertheless, in comparison with VRCA, their precisions are also too weak, since they keep many useless features in cluster's vector. These features decrease clustering precision. For K-means, STING, DBSCAN, and BIRTH, they not only run in uncompressed space, but also do nothing to remove useless features from cluster's vector. Their precisions are the lowest.

4.3 Time Performance

Due to the high-dimensional vectors generated by vector space model, traditional clustering algorithms are timeconsuming on clustering large-scale text collection. In order to demonstrate our algorithm's high efficiency, we record running time of different algorithms in Table 3.

Two observations can be found from Table 3: (a) VRCA spends the least time on ClueWeb9, TRC2, and spends the second least time on Reuters, while VRCA only ranks the fourth on Newsgroup. By contrast, on Reuters and Newsgroup, K-means has the best time performance, and ranks the second on ClueWeb9 and TRC2; (b) all the algorithms spend similar amount of time when text collection is small, while when it enlarges, VRCA spends extremely less time. The reason to this phenomenon mainly attributes to VRCA's reconstructive plan and its fast intersection based similarity measurement, where only the features that are useful to represent cluster are adopted in similarity calculation. In comparison with VRCA, K-means, STING, DBSCAN, BIRTH, GSOM, and GHSOM all generate high-dimensional vectors, and consequently run much slower. Since K-means, GSOM, GHSOM own linear time complexity, and STING, DBSCAN run by space partition, their running time is less than the others. However, due to the high-dimensional vectors, their time performances are lower than VRCA. In comparison with the pervious baseline algorithms, the vectors generated by Spectral Clustering, NRMF, and LDCC are much denser and shorter, whereas they need to perform an additional dimension reduction process. Thus, they are also time-consuming. BIRTH is one kind of hierarchical clustering algorithms, thus it has square time complexity and spends the most time.

5 Conclusions

Because of the high-dimensional problem aroused by vector space model and time-consuming issue brought from concurrence based similarity measurement, most of traditional clustering algorithms fail to cluster large-scale text collection. Facing the massive amount of web texts, only if clustering algorithms can efficiently handle large-scale text collection, they can be used in real applications. Thus, this paper proposes a clustering algorithm particularly for large-scale texts. This algorithm consists of two sub-processes and alternately repeats them until convergence. The two sub-processes are: partial tuning sub-process and overall tuning sub-process. In the former sub-process, an iterative tuning process based on SOM is adopted to tune neuron vector. Besides, an intersection based similarity measurement is also implemented. In the latter sub-process, two measures are calculated to choose features to reconstruct cluster's vector. Through comparing our algorithm with the other nine popular clustering algorithms, it demonstrates that our algorithm performs well on both small-scale and large-scale text collections.

Acknowledgments

This research is supported by National Natural Science Foundation of China (No. 61300114), Specialized Research Fund for the Doctoral Program of Higher Education (No.20132302120047), the Special Financial Grant from the China Postdoctoral Science Foundation (No.2014T70340), CCF-Tencent Open Fund.