Brain-inspired Search Engine Assistant
based on Knowledge Graph

DeveloperBot incorporates the tool named coreNLP to do the tokenization, POS (Part of Speech) tagging, dependency parsing and lemmatization to the query [44, 45, 46, 47]. The task of tokenization is to break the sentence into small pieces, called tokens, and drop some characters like punctuation. POS (Part of Speech) tagging is the process of labelling words with their grammatical properties, such as NN: Noun, singular or mass, WP: Whpronoun, VBZ: Verb, 3rd person singular present, etc. Lemmatization can reduce inflectional forms and derivative related forms of a word to a common base form.

Dependency is the grammatical structure between the Governor and Dependent. Tab. I presents the detailed description of key dependencies of a sample query (Unless otherwise specified, the sample query in this paper refers to the query: “Which graph databases support Python and can be accessed through the RDF query languages that support subgraph extraction?”). As Tab. I shows, “det” is the abbreviation of determiner. There are three interrogative determiners: what, which, whose. “nsubj” is a NP and acts as a passive syntactic subject of a clause [48]. For our sample query, nsubj (support-4, databases-3) means that “databases-3” is the syntactic subject of the verb “support-4”. In general, the “nmod” indicates some further adjunct relation specified by the case.

In this step, a fulltext parsing technique called “Tree Parsing” is adapted to segment a sentence into its subconstituents [49, 50, 51, 34]. As shown in Tab. II, DeveloperBot sets four subconstituents called WHNP, WHVP, NP and VP. Here NP and VP are abbreviations of the noun phrase and verb phrase, respectively. Subconstituent WHNP represents a phrase beginning with “which”, “what” or “whose” followed by a noun phrase (e.g. Which relational databases). If a phrase starts with “who”, “when” or “what” followed by a verb phrase, WHVP will be the name of this subconstituent (e.g. Who developed).

The second column of Tab. II is the parsing expressions of the above four subconstituents. These parsing expressions are represented by POS tags. In the parsing expressions, “?” stands for whether or not there is such a determinant; “*” means zero or more determinant; “+” means must have such a determinant; “-” means continue to next row. Using the tree parsing, the tokens of the sentence are segmented to WHNP, WHVP, VP and NP as shown in Fig. 3.

Assume there is a query $Q$, the query graph constructed by BotPerception and BotPlanning is represented as $QG$. A $QG$ is composed of the basic units called constraint quads which consists of four basic elements represented as (category constraint, predicate relation of category constraint and property constraint, property constraint, layer number). The layer number refers to the solving order of this constraint. A higher layer number means that the constraint is outer layer of $QG$, and the solving sequence is earlier.

Firstly, we use the constituency-based tree parsing to parse $Q$ and get $m$ WHNP, $n$ WHVP, $p$ NP and $q$ VP in $Q$. Assuming $WHNP_{i}$, $WHVP_{j}$, $NP_{k}$ and $VP_{s}$ are the $i$th WHNP, $j$th WHVP, $k$th NP and $s$th VP respectively in $Q$:

where $whnp_{if}$, $whvp_{jt}$, $np_{kr}$ and $vp_{st}$ are $f$th, $w$th, $r$th and $t$th word of $WHNP_{i}$, $WHVP_{j}$, $NP_{k}$ and $VP_{s}$, and the total number of words of them are $x$, $y$, $u$, and $v$, respectively.

Secondly, the dependency parsing technique is used to add dependency markups to all words of $Q$. After in-depth observation and analysis to the questions on Stack Overflow and our data set, we summarize the query sentence structures commonly used by developers and propose the following 5 query constraints and their layers extraction patterns to construct a query graph.

Pattern 1: If in a query $Q$, $m=1$ and $n=0$, and WHNP is detected at the beginning of $Q$. The NP following the interrogative word called $WHNP_{NP}$ is regarded as a category constraint of direct answers. Assuming $whnp_{npe}$ is the $e$th word of $WHNP_{NP}$, if the following 4 dependency pairs are detected:

• •

  $dp[nsubj~{}(vp_{st},whnp_{npe}),dobj~{}(vp_{st},np_{kr})]$

• •

  $dp[nsubjpass~{}(vp_{st},whnp_{npe}),dobj~{}(vp_{st},np_{kr})]$

• •

  $dp[nsubj~{}(vp_{st},whnp_{npe}),nmod~{}(vp_{st},np_{kr})]$

• •

  $dp[nsubjpass~{}(vp_{st},whnp_{npe}),nmod~{}(vp_{st},np_{kr})]$

where $dp[a,b]$ means that $a$ and $b$ appear simultaneously in the result of dependency parsing of $Q$. Then a property constraints ($VP_{s}$, $NP_{k}$) will be extracted into the $QG$.

For the sample query, “Which graph databases” is a WHNP at the beginning of the query phrase and “graph databases” is the $WHNP_{NP}$ as shown in Fig. 3. Therefore, (graph_databases) will be extracted as a category constraint of direct answers. Then, two dependency pairs $dp[nsubj~{}(support-4,databases-3)$ and $dobj(support-4,Python-5)]$ and $dp[nsubjpass~{}(accessed-9,databases-3)$ and $nmod~{}(accessed-9,languages-14)]$ are detected. Here “support-4” is $vp_{11}$ which means the first word in the first VP of $Q$. The “databases-3” is $whnp_{np2}$ representing the second word of NP of WHNP and so on.

In BotPerception, all property constraints belonging to category constraints of direct answers are classified as the innermost layer of $QG$. Therefore, from the sample query, Pattern 1 can extract two constraint quads: (graph_databases, support, Python, 1) and (graph_databases, can_be_accessed_through, RDF_query_languages, 1)

Pattern 2: Assuming the “property constraints” of a constraint quads is $PC=(pc_{1},pc_{2},...,pc_{g},...,pc_{d})$, where $pc_{g}$ is the $g$th word of $PC$, and there are $d$ words in $PC$ in total.

If a constraint quads has been extracted and its layer number equal to $c$. And then if the following 4 dependency pair are detected:

• •

  $dp[nsubj~{}(vp_{st},pc_{g}),dobj~{}(vp_{st},np_{kr})]$

• •

  $dp[nsubjpass~{}(vp_{st},pc_{g}),dobj~{}(vp_{st},np_{kr})]$

• •

  $dp[nsubj~{}(vp_{st},pc_{g}),nmod~{}(vp_{st},np_{kr})]$

• •

  $dp[nsubjpass~{}(vp_{st},pc_{g}),nmod~{}(vp_{st},np_{kr})]$

A constraint quads ($PC$, $VP_{s}$, $NP_{k}$, $c+1$) will be extracted into the $QG$.

For the sample query, a constraint quads (graph_databases, can_be_accessed_through, RDF_query_languages, 1) has been extracted, so $PC$ = “RDF query languages”. A dependency pair $dp[nsubjpass~{}(accessed-12,databases-3),nmod~{}(accessed-9,languages-14)]$ is detected. Here “accessed-9” is $vp_{23}$, “databases-3” is $pc_{3}$, “languages-14” is $np_{34}$ as shown in Fig. 3. So the constraint quads (RDF_query_languages, support, subgraph_extraction, 2) will be extracted into the $QG$.

Pattern 3: In a query $Q$, if $whvp_{11}$ is “who” and $WHVP_{VP}$ is not “is”, “PERSON” will be added to $QG$ as a category constraint of direct answers. For example, a query “Who created Python?” will be constructed as (PERSON, created, Python, 1), where the $whvp_{11}$ equals to “when”, a category constraint “DATE” will be added into $QG$. If $whvp_{11}$ is “what” and $WHVP_{VP}$ is not “is”, a category constraint ANYENTITY (a wildcard of any entities) will be put into $QG$.

Pattern 4: If in a query $Q$, WHVP is detected at the beginning of the $Q$. The VP following the interrogative word is “is” and the $whvp_{vp1}$ is not “when” like query “What is Java Servlet?”. We will regard this question as a definition query and construct the $QG$ as (ANYENTITY, ANYRELATION, Java_Servlet, 1) and (Java_Servlet, ANYRELATION, ANYENTITY, 1), where ANYRELATION represents a wildcard of any relation.

Pattern 5: If in a query $Q$, $m=0,n=0$, and the first word of $Q$ is “List” followed by only an NP. e.g. “List graph database”. We will construct the $QG$ as (graph_database, ANYRELATION, ANYENTITY, 1).

Assuming the current constraint quads for candidate subgraph search is $(c_{subj},c_{predicate},c_{obj},c_{layer})$, and the knowledge graph $KG=[node_{1},node_{2},...,node_{i},...,node_{n}]$, where $node_{i}$ is the $i$th node of $KG$, $n$ is the nodes number of $KG$. The pseudo code of subgraph search is shown in Algorithm. 1.

Each node in $KG$ has an initial associated activation value $a_{i}\in\mathbb{R}$ and $0<a_{i}<1$. A link $link_{ij}$ connects source $node_{i}$ to target $node_{j}$ and the weight of $link_{ij}$ is $w_{ij}$ where $w_{ij}\in\mathbb{R}$ and $0<w_{ij}<1$. The nodes of $KG$ have an active threshold $AT$, where $AT\in\mathbb{R}$ and $0<AT<1$. There is a decay factor $DF$, where $DF\in\mathbb{R}$ and $0<DF<1$.

In the beginning of the subgraph search, BotReasoning links the $c_{subj}$ and $c_{obj}$ to the corresponding $node_{subj}$ and $node_{obj}$ in $KG$. Therefore, the initial activation value of $node_{subj}$ and $node_{obj}$ will be greater than active threshold $AT$. These two nodes are activated and will initiate to spread the activation to all the neighbouring nodes parallelly.

Assuming $link_{ij}$ connects the source node $node_{i}$ to the target node $node_{j}$. While the activation spread from $node_{i}$ to $node_{j}$, $node_{i}$ will compute $a_{j\_temp}$ as:

Then, $a_{j}$ will adjust its value to $a^{\prime}_{j}$ according to $a_{j\_temp}$ as following formula:

Once $node_{j}$ is activated, it will initiate the next spreading activation cycle to its neighbouring nodes. The spreading will be terminated under the following three situations:

• •

  The spreading arrives the endmost nodes of the $KG$ or exceeds the preset upper bound $ST$.

• •

  All the nodes reach $AT$.

• •

  During searching $node_{obj}$, if the neighbouring node $node_{j}$ of $node_{i}$ belongs to $SG_{subj}$. The spreading will be terminated and $(node_{j},link_{ij},node_{i})$ will be inserted into $CR$, where $CR$ are the crossover relations indicating the relations of $c_{subj}$ and $c_{obj}$.

Topological Structure of Subgraph $SG$: Fig. 4 illustrates an example of $SG$. The root node and leaf node refer to the most superclass node and most subclass node of $SG$, respectively. The candidate answers are all the leaf nodes of $SG_{subj}$.

Assuming the red focus node in Fig. 4 is a candidate answer for making decision (to decide the candidate answer is a correct answer or not). The following two kinds of potential topological structures of the $CR$ can affect the decision-making. $R1$ refers to the candidate answer or any superclasses of the candidate answer connected to $c_{obj}$ or any superclasses of $c_{obj}$ by the predicate. $R2$ indicates that the candidate answer or any superclasses of candidate answer connect to any subclasses of $c_{obj}$ by the predicate.

Predicate Similarity: There are many different ways to express the same meaning and opposite meaning. Therefore, the predicates of $CR$ also affect the decision-making. To measure the semantic relevance between two predicates, a technique named word2vec [52, 53, 54] is adopted. It assumes that words appear in similar context may have similar meanings [55] and transforms the words or phrases into the form of continuous vectors [52]. Then words or phrases can do relevance computation by distance measurement of vector (here we use cosine similarity).

Features Generations: In order to estimate the candidate answers, sufficient evidence need to be gathered to determine whether it surpasses the positive or negative criteria. In general, the weights of positive and negative evidence are not equal. A few negative evidence may lead to negative decisions, whereas many positive evidence are needed to make a positive decision.

We synthesize the topological structure and predicate similarity into four features as shown in Tab.III. In these four features, feature #1 represents the influence of $R1$. If $R1$ does not exist, the value of feature #1 takes 0, otherwise takes the maximum value of predicates similarity of all $R1$: $p\_r1\_pdictSim=max(pdictSim\_R1_{i})$, where $i=(1,2,...,n)$ and $pdictSim\_R1_{i}$ is the predicates similarity of $i$th $R1$, and $n$ is the number of $R1$.

Feature #2 represents the influence of $R2$. If $R2$ does not exist, the value takes 0. Otherwise, the more $R2$ in $CR$, the higher the probability that the candidate answer meets the property constraint. Therefore, the value of feature #2 $p\_r2\_pdictSim=\frac{1}{mn}\sum_{i=1}^{m}\sum_{j=1}^{n}pdictSim\_R2_{ij},i=(1,2,...,m),j=(1,2,...,n)$, where $pdictSim\_R2_{ij}$ is the predicates similarity of $i$th leaf nodes of $c_{subj}$ connected to $j$th subclass of $c_{obj}$. $m$ is the number of leaf nodes of $c_{subj}$ and $n$ is the number of subclasses of $c_{obj}$. Take the Fig. 4 as an example, here $m=2$, and $n=2$, assume the value of $pdictSim\_R2_{21}=1$ and $pdictSim\_R2_{22}=0.5$, the value of feature #2 is $\frac{(1+0.5)}{4}=0.375$. For the feature #3 and feature #4, if negative $R1$ or $R2$ do not exist, the value takes 0, otherwise, takes 1.

BotReasoning extracts the layer information of $QG$ and the answer reasoning will be performed from the outer layer to the inner layer. The reasoning order of the constraint quads in same layer is determined by random. Once the answers $AS=(as_{1},as_{2},...,as_{n})$, where $n\geq 0,n\in\mathbb{Z}$ of a constraint quads $currentCQ$ are found, BotReasoning will replace the corresponding object constraint in the inner layer by these answers and prune the $currentCQ$ from $QG$. BotReasoning will generate $n$ pruned $QG$, and continues the reasoning process for every $QG$. If there are multiple constraints in the same layer and multiple answer sets are deduced, the union of these sets is computed. These iterations will terminate until the final answers and explanations of the most inner layer of every $QG$ are achieved.

The corresponding explanations (reasoning subgraph and answer confidence) are extracted following the cognitive process of DeveloperBot. BotPerception records the entities identified in a query to the reasoning subgraph, these are also the initially activated nodes ($node_{subj}$ and $node_{obj}$) for spreading activation in the knowledge graph. After every constraint reasoning, BotReasoning takes all the $CR$ and the relational paths from $node_{subj}$ or $node_{obj}$ to any nodes of $CR$ into the reasoning subgraph of previous iteration (if any). Therefore, the final reasoning subgraph involves the information of whole cognitive process including BotPerception, BotPlanning and BotReasoning.

The answer confidences $AC=(ac_{1},ac_{2},...,ac_{m})$, where $m\geq 0,n\in\mathbb{Z}$ for $currentCQ$ are computed by the decision-making algorithm multiplicative the answer confidence from outer layer. During the answer reasoning, the confidences $ac_{i}$ will be multiplicative to every confidence of the inner layer. The confidence of an answer reasoned from multiple constraints in the same layer is obtained by multiplying the answer confidences of all the constraints in the same layer.

In the quantitative evaluation, we invited five developers to ask some multi-constraint natural language questions they interested. We require that these questions should be answered with direct answers. These questions mainly cover factual questions such as Who, What, Which, and List. Finally, the five developers proposed 160 eligible questions. Then they asked to use computer to search their answers for every question. Then they discuss together about the final answers for every question. 51 of the questions were dropped because they had no answer, or their answers could not reach a consensus. Then the 109 ground truth questions and the 1819 candidate answers generated.

To evaluate the decision-making process, the balanced accuracy, precision, recall, f1-score and confidence mean square error (MSE) are used as evaluation metrics [61]. The average result of the 10 times cross-validation will be taken as the final results of different metrics. Here the MSE measures the average squared difference between the estimated confidence values and the actual confidence values: $MSE=\frac{1}{n}\sum_{i=1}^{n}(1-answerConfidence_{i})^{2}$, where $n$ is the number of answers, the 1 is the actual confidence values for correct answers. The balanced accuracy returns the average accuracy per class: $BalancedAccuracy=\frac{1}{2}\left(\frac{TP}{TP+FN}+\frac{TN}{TN+FP}\right)$, where $TP$, $TN$, $FP$, $FN$ are true positives, true negatives, false positives, and false negatives, respectively.

Tools for comparison: In this user study, we will compare the information search performance of using Google + DeveloperBot with use only Google. There are some direct answer search engines like Wolfram Alpha (https://www.wolframalpha.com/) and ASK (https://www.ask.com) which are similar to DeveloperBot. But these tools can hardly answer specific questions of software engineer domain, so it makes no sense to compare with them. Furthermore, this paper mainly focuses on a general method to answer questions and provide explanations by a knowledge graph. It can be extended to many different areas, situations and questions coverage, which depend on the knowledge graph used.

Participants: In the user study, 24 developers from different backgrounds were recruited. They are made up of the employees, undergraduate students, PhD students, professors from different universities and professional developers from IT companies, etc. Their programming proficiency distributions are 12.5%, 75% and 12.5% for expert, competent and beginner, respectively. The participants also have diverse programming background and their programming languages involved Python, Java, Javascript, SQL, C#, etc. In each proficiency level and background, the developers are halved to $G1$ and $G2$ randomly (12 participants per group). To exclude the effects of participants’ programming level and fatigue, $G1$ and $G2$ will act as experimental group (use Google + DeveloperBot) and control group (use only Google) to finish each task circularly Therefore, every developer has the opportunity to solve the simple or hard task by only Google or Google + DeveloperBot. They can also have a comprehensive comparison to the differences with or without the search engine assistant DeveloperBot.

Task: In this study, we have chosen 5 answer search tasks (represent as $Task1-Task5$) from the ground truth questions as shown in Tab. LABEL:tasks. The answer to these tasks cover celebrity of software engineering domain, library, operating system, IDE, and database, etc. According to the preliminary test, the difficulty of these five tasks increases in order. The participants need to evaluate all the answers given by Google or DeveloperBot comprehensively, and select $x$ best answers according to the required number of every task.

Procedure: This user study begins with a brief training of DeveloperBot by the experimenter. After finishing each task, participants need to fill their confidence to the answers they provided (on 5-point likert scale with 1 being the least confident and 5 being the most confident). A screencapture software is required to run throughout the whole process that allows us to analyze the participants’ behavior after the experiment. At the end, all the participants will be asked to fill in the System Usability Scale (SUS) questionnaire [62] and do an open discussion focusing on their options about the different features of DeveloperBot.

Here we will present the results of quantitative evaluation and answer the RQ1. Fig.6 shows the performance of different decision-making algorithms including Random Forest, Decision Tree, SVM Linear, Bayes (Bayesian Decision Theory), and DNN. With the accurate representation of candidate answers by the four features extracted by our algorithm, any decision-making algorithm can get more than 0.98 balanced accuracy. Compared with another algorithms, DNN achieves the highest precision 0.98, recall 0.98 and f1-score 0.99, respectively. From Fig.6, we can infer that some decision-making algorithms can achieve high precision, but at the cost of a low recall, like SVM Linear. The Bayesian Decision theory obtains a high recall, but the precision is low. In the future research, we might investigate the employment of other state-of-art algorithms, such as negative correlation learning [63, 64], statistical learning for probabilistic outputs [65, 66], Bayesian inference [67], etc.

Fig.7 is the MSE of confidence for different decision-making algorithms. It shows that DNN achieves the lowest MSE for the estimation of answer confidence. Bayesian Decision Theory gets the highest MSE. The estimation of answer confidence is within the acceptable range for all decision-making algorithms.

To explore the effects of different features, we train 3 DNN models using different features. These 3 models use all features, only predicate similarity feature and only topological structure feature, respectively. The only predicate similarity feature is computed by the maximal predicate similarity of $R1$, if it exists. Only topological structure features involve 4 features to represent the existence (take the value 1) or nonexistence (take the value 0) of $R1$, $R2$, $R3$ and $R4$, respectively.

As shown in Fig.8, the decision-making algorithm with all features performs the best for all the metrics. This figure also indicates that the predicate similarity contributes to the precision significantly. Since with only predicate similarity feature, the precision almost can achieve as same as all features. But only predicate similarity feature obtains very low recall. These results show that the predicate similarity is a good feature in terms of identifying the right answers, but without the topological structure, a lot of right answers are missed.

Fig.9 indicates that the decision-making algorithm can obtain the lowest MSE by using all features. Compared with the topological structure, predicate similarity achieves higher MSE. From the above exploration, we can infer that both predicate similarity and topological structure we design for decision-making are useful for identifying the right answer from the candidate answers.

Fig.10 is the result of the average answer accuracy of the two groups. It shows that for the task 1-2, both groups can finish the tasks with high accuracy (above 0.86). The answer accuracy of the participants who use only Google even reaches 1 on task 1. These prove our pre-experiment conjecture: Google has a very good performance in simple information search tasks. For the task 3-5, the experimental group can finish with higher answer accuracy. With the complexity of tasks increasing, the answer accuracy of the control group gradually decreases compared with the experimental group which maintains at a high level (above 0.78). For task 5, the difference in answer accuracy even reaches 0.64. These fully illustrate that DeveloperBot, as a search engine assistant, can significantly improve the answer accuracy during search close-end questions, especially in complex search tasks.

Fig.11 is the result of participants’ average confidences to their answers (called participants’ confidences). This figure indicates that for tasks 1-3, the participants’ confidences of control group are almost same as experimental group. For tasks 4-5, the participants’ confidences (4 and 4.3 for task 4 and task 5, respectively) of the experimental group show an overwhelming advantage. With the complexity of tasks increasing, the difference of participants’ confidences of two groups shows a clear increasing trend except task 3. According to the observation of the screen recording and results of the open discussion, this is because there is a web page that lists some direct answers of task 3, and each answer has corresponding text explanation. The participants’ confidences of control group increases by reading these text explanation. But this is at the cost of increasing the time used on task 3 as shown in Fig. 12. These indicated that for the easy tasks, the control group was more confident in their answers because they were straightforward and did not require reasoning or summarization. For the complex tasks, despite spending a long time to search answers, participants still feel less confident to their answers because they may lose during they try to summarize and reason the answers through many web pages. Therefore, as a search engine assistant, DeveloperBot can improve the participants’ confidences by providing explanations of answers.

Fig.12 is the result of answers search time. It shows that, in addition to task 3, the answers search time of the control group increases significantly with the complexity of the tasks increasing. With the assistant of DeveloperBot, the answer search time of the experimental group for task 5 is 258s compared with 405s of the control group. These show that using DeveloperBot as search engine assistant can significantly reduce the participants’ answer search time especially for the complex answer search tasks that take a long time to solve with only Google. The open discussion also reflects consistent results for the above conclusion. The special performance of Google group at task 3 also illustrates that direct answers and the explanation (even text) can significantly reduce the search time and improve the participants’ confidences to their answers at the same time.

We will evaluate the explanation and answer the RQ3 from three ways: the quantitative scoring (0-5) of participants in the questionnaires, the information obtained from open discussions, and our observation of screen recording.

The results of the quantitative scoring of explanations are shown in the radar graph Fig. 13. Five indexes are adopted in this experiment to evaluate the quality of the explanation. They are Readable, Understandable, Answer Convincing, Wrong Answer Identification and Search Keywords Forming [68, 69], where Readable and Understandable mean the explanation is legible, easy to read and understand. Answer Convincing means this explanation can make the direct answer more convincing. Wrong Answer Identification is the index that evaluates if the explanation can help identify the wrong answer. Search Keywords Forming shows the capacity of the explanation to help form better search keyword.

As shown in Fig. 13, the overall scores of reasoning subgraph reach 4.13-4.71. Compared with the other four indexes, the Answer Convincing achieves the highest score 4.71. The ranking of indexes of Readable and Understandable are second and third, with average values of 4.38. Even the Wrong Answer Identification achieves the lowest score, 4.13 is still acceptable. The results demonstrate that the reasoning subgraph is a reasonable and high-quality explanation of direct answer and meet the desired design goals.

In addition, Fig. 13 also shows the overall scores of using confidence as an explanation. Compared with the reasoning subgraph, the overall scores of confidence are relatively lower (3.71-4.17). The indexes Readable, Understandable and Answer Convincing achieve highest score 4.17. The scores of Wrong Answer Identification and Search Keywords Forming is 3.79 and 3.71, respectively. Even the overall scores of confidence are lower than reasoning subgraph, especially the Search Keywords Forming and Wrong Answer Identification. However, the good performance of indexes like readable, understandable and answer convincing indicate that confidences are good explanations to direct answers.

The results of the questionnaire and the contents of the open discussion show that, using the reasoning subgraph extracted following the cognitive process and answer confidence as explanations of the direct answers can significantly improve the developers’ trust and adoption to the answers. These explanations also assist the developers to understand the answers more deeply, improve the answer accuracy and form better search keywords.