Program induction for answering complex questions over knowledge bases (KBs) aims to decompose a question into a multi-step program, whose execution against the KB produces the final answer. Learning to induce programs relies on a large number of parallel question-program pairs for the given KB. However, for most KBs, the gold program annotations are usually lacking, making learning difficult. In this paper, we propose the approach of program transfer , which aims to leverage the valuable program annotations on the rich-resourced KBs as external supervision signals to aid program induction for the low-resourced KBs that lack program annotations. For program transfer, we design a novel two-stage parsing framework with an efficient ontology-guided pruning strategy. First, a sketch parser translates the question into a high-level program sketch, which is the composition of functions. Second, given the question and sketch, an argument parser searches the detailed arguments from the KB for functions. During the searching, we incorporate the KB ontology to prune the search space. The experiments on ComplexWebQuestions and WebQuestionSP show that our method outperforms SOTA methods significantly, demonstrating the effectiveness of program transfer and our framework. Our codes and datasets can be obtained from https://github.com/ THU-KEG/ProgramTransfer . Answering complex questions over knowledge bases (Complex KBQA) is a challenging task requiring logical, quantitative, and comparative reasoning over KBs (Hu et al., 2018; Lan et al., 2021). Recently, the program induction (PI) paradigm, which gains increasing study in various areas (Lake et al., 2015; Neelakantan et al., 2017; Wong et al.,  Corresponding Author Program Relate Find Relate FilterConcept FilterConcept Find Question What Barcelonafacility whereFC Barcelonaplays canI visit? Answer Camp Nou What And FilterConcept touristattraction Relate tourist attractions Find Barcelona Find FC Barcelona Relate arenastadium FilterConcept sportsfacility Figure 1: An example question, the corresponding program, and the answer. The left side is the sketch, and the right side is the complete program, with dotted boxes denoting arguments for functions. 2021), emerges as a promising technique for Complex KBQA (Liang et al., 2017; Saha et al., 2019a; Ansari et al., 2019). Given a KB, PI for Complex KBQA aims to decompose a complex question into a multi-step program, whose execution on the KB produces the answer. Fig. 1 presents a complex question and its corresponding program whose functions take KB elements ( i.e. , entities, relations and concepts) as arguments. E.g. , the relation tourist attractions is the argument of function Relate . For most KBs, the parallel question-program pairs are lacking because such annotation is both expensive and labor-intensive. Thus, the PI models have to learn only from question-answer pairs. Typically, they take the answers as weak supervision and search for gold programs with reinforcement learning (RL) (Saha et al., 2019b; Liang et al., 2017; Ansari et al., 2019). The combinatorial explosion in program space, along with extremely sparse rewards, makes the learning challenging. Abundant attempts have been made to improve the stability of RL algorithms with pseudo-gold programs (Liang et al., 2017), noise-stabilizing wrapper (Ansari et al., 2019), or auxiliary rewards (Saha et al., 2019b). Despite promising results, they re-8128 quire significant human efforts to develop carefully-designed heuristics or are constrained to relatively simple questions. Recently, for several KBs, there emerge question-program annotation resources (Johnson et al., 2017; Cao et al., 2022). Thanks to the supervision signals ( i.e. , program annotation for each question), the PI models on these rich-resourced KBs achieve impressive performance for even extremely complex questions, and are free from expert engineering. Intuitively, leveraging these supervision signals to aid program induction for low-resourced KBs with only weak-supervision signals ( i.e. , question-answer pairs) is a promising direction. In this paper, we formalize it as Program Transfer . In practice, program transfer is challenging due to the following reasons: (a) Domain Heterogeneity . The questions and KBs across domains are both heterogeneous due to language and knowledge diversity (Lan et al., 2021). It is hard to decide what to transfer for program induction. (b) Unseen KB Elements. The coverage of source KB is limited, e.g. , KQA Pro in (Cao et al., 2022) covers only 3.9% relations and 0.24% concepts of Wikidata. Thus, most elements in the massive scale target KB are not covered in the source. (c) Huge Search Space. The search space of function arguments depends on the scale of target KB. For realistic KBs containing millions of entities, concepts and relations, the huge search space is unmanageable. To address the above problems, we propose a novel two-stage parsing framework with an efficient ontology-guided pruning strategy. First, we design a sketch parser to parse the question into a program sketch (the left side in Fig. 1), which is composed of functions without arguments. As Baroni (2019) points out, the composition of functions well captures the language compositionality. Translation from questions to sketches is thus relevant to language compositional structure and independent of KB structure. Therefore, our sketch parser can transfer across KBs. Second, we design an argument parser to fill in the detailed arguments (typi-cally KB elements) for functions in the sketch. It retrieves relevant KB elements from the target KB and ranks them according to the question. Specifically, it identifies KB elements with their label descriptions and relies on language understanding to resolve unseen ones. We further propose an ontology-guided pruning strategy, which introduces high-level KB ontology to prune the candidate space for the argument parser, thus alleviating the problem of huge search space. Specifically, the sketch parser is implemented with a Seq2Seq model with the attention mechanism. The argument parser identifies elements through semantic matching and utilizes pre-trained language models (Devlin et al., 2019) for language understanding. The high-level ontology includes the domain and range of relations and entity types. In evaluation, we take the Wikidata-based KQA Pro as the source, Freebase-based ComplexWebQuestions and WebQuestionSP as the target domain datasets. Experimental results show that our method improves the F1 score by 14.7% and 2.5% respectively, compared with SOTA methods that learn from question-answer pairs. Our contributions include: (a) proposing the approach of program transfer for Complex KBQA for the first time; (b) proposing a novel two-stage parsing framework with an efficient ontology-guided pruning strategy for program transfer; (c) demonstrating the effectiveness of program transfer through extensive experiments and careful ablation studies on two benchmark datasets. KBQA . KBQA aims to find answers for questions expressed in natural language from a KB, such as Freebase (Bollacker et al., 2008), DBpedia (Lehmann et al., 2015) and Wikidata (Vran-decic and Krtzsch, 2014). Current methods for KBQA can be categorized into two groups: 1) semantic parsing based methods (Berant et al., 2013; Yih et al., 2015; Cheng et al., 2017; Liang et al., 2017; Ansari et al., 2019), which learn a semantic parser that converts questions into intermediate logic forms which can be executed against a KB; 2) information retrieval based methods (Bor-des et al., 2014; Xu et al., 2016; Miller et al., 2016; Zhang et al., 2018; Sun et al., 2018, 2019; Shi et al., 2021), which retrieve candidate answers from the topic-entity-centric subgraph and then rank them according to the questions. Recently, semantic parsing for KBQA has gained increasing research attention because the methods are effective and more interpretable. Multiple kinds of logical forms have been proposed and researched, such as SPARQL (hommeaux, 2011),  DCS (Liang, 2013),  -calculus (Artzi et al., 2013), query graph (Yih et al., 2015), program (Liang et al., 2017). PI aims to convert questions into 8129 programs, and is in line with semantic parsing. Cross-domain Semantic Parsing. Cross-domain semantic parsing trains a semantic parser on some source domains and adapts it to the target domain. Some works (Herzig and Berant, 2017; Su and Yan, 2017; Fan et al., 2017) pool together examples from multiple datasets in different domains and train a single sequence-to-sequence model over all examples, sharing parameters across domains. However, these methods rely on annotated logic forms in the target domain. To facilitate low-resource target domains, (Chen et al., 2020) adapts to target domains with a very limited amount of annotated data. Other works consider a zero-shot semantic parsing task (Givoli and Reichart, 2019), decoupling structures from lexicons for transfer. However, they only learn from the source domain without further learning from the target domain using the transferred prior knowledge. In addition, existing works mainly focus on the domains in OVERNIGHT (Wang et al., 2015), which are much smaller than large scale KBs such as Wikidata and Freebase. Considering the complex schema of large scale KBs, transfer in ours setting is more challenging. Knowledge Bases . Knowledge base describes concepts, entities, and the relations between them. It can be formalized as KB = {C , E , R , T } . C , E , R and T denote the sets of concepts, entities, relations and triples respectively. Relation set R can be formalized as R = { r e , r c }  R l , where r e is instanceOf , r c is subClassOf , and R l is the general relation set. T can be divided into three disjoint subsets: (1) instanceOf triple set T e = { ( e, r e , c ) | e  E , c  C} ; (2) subClassOf triple set T c = { ( c i , r c , c j ) | c i , c j  C} ; (3) relational triple set T l = { ( e i , r, e j ) | e i , e j  E , r  R l } . Program . Program is composed of symbolic functions with arguments, and produces an answer when executed against a KB. Each function defines a basic operation on KB and takes a specific type of argument. For example, the function Relate aims to find entities that have a specific relation with the given entity. Formally, a program y is denoted as (cid:10) o 1 [ arg 1 ] ,    , o t [ arg t ] ,    , o | y | [ arg | y | ] (cid:11) , o t  O , arg t  E  C  R . Here, O is a pre-defined function set, which covers basic reasoning opera-Function ArgumentType Argument Description Find entity FC Barcelona Find the specific KB entity Relate relation arena stadium Find the entities that hold a specific relation with the given entity FilterConcept concept sports facility Find the entities that belong to a specific concept And -Return the intersection of two entity sets Table 1: Function examples. tions over KBs (Cao et al., 2022). According to the argument type, O can be devided into four disjoint subsets: O = OE  OC  OR  O  , representing the functions whose argument type is entity, concept, relation and empty respectively. Table 1 gives some examples of program functions. Program Induction . Given a KB , and a complex natural language question x = (cid:10) w 1 , w 2 ,    , w | x | (cid:11) , it aims to produce a program y that generates the right answer z when executed against KB . Program Transfer . In this task, we have access to the source domain data S = (cid:10) KBS , DS (cid:11) , where DS contains pairs of question and program { ( x Si , y Si ) } n S i =1 ; and target domain data T = (cid:10) KBT , DT (cid:11) , where DT contains pairs of question and answer { ( x Ti , z Ti ) } n T i =1 . We aim at learning a PI model to translate a question x for KBT into program y , which produces the correct answer when executed on KBT . As mentioned in the introduction, to perform program transfer for Complex KBQA, we need to address three crucial problems: (1) What to transfer when both questions and KBs are heterogeneous? (2) How to deal with the KB elements unseen in the external annotations? (3) How to prune the search space of input arguments to alleviate the huge search space problem? In this section, we introduce our two-stage parsing framework with an ontology-guided pruning strategy, which is shown in Fig. 2. (1) Sketch Parser : At the first stage, we design a sketch parser f s to parse x into a program sketch y s = (cid:10) o 1 ,    , o t ,    o | y | (cid:11) , which is a sequence of functions without arguments. The sketch parsing process can be formulated as y s = f s ( x ) . Translation from question to sketch is relevant to language compositionality, and irrelevant to KB structure. Therefore, the sketch parser can generalize across KBs. (2) Argument Parser : At the second stage, we design an argument parser f a to retrieve the argument arg t from a candidate pool P for each function o t , which can be formulated as arg t = f a ( x, o t , P ) . Here, the candidate pool P contains the relevant elements in KBT , including concepts, entities, and relations. In a real KB, the candidate pool is usually huge, which makes searching and learning from answers very hard. Therefore, we propose an ontology-guided pruning strategy, which dynamically updates the candidate pool and progressively reduces its search space. In the following we will introduce the implementation details of our sketch parser (Section 4.1), argument parser (Section 4.2) and training strategies (Section 4.3). The sketch parser is based on encoder-decoder model (Sutskever et al., 2014) with attention mechanism (Dong and Lapata, 2016). We aim to estimate p ( y s | x ) , the conditional probability of sketch y s given input x . It can be decomposed as: p ( y s | x ) = | y s | (cid:89) t =1 p ( o t | o <t , x ) , (3) where o <t = o 1 , ..., o t  1 . Specifically, our sketch parser comprises a question encoder that encodes the question into vectors and a sketch decoder that autoregressively outputs the sketch step-by-step. The details are as follows: Question Encoder. We utilize BERT (Devlin et al., 2019) as the encoder. Formally, x , ( x 1 ,    , x i ,    , x | x | ) = BERT ( x ) , (4) where x  R  d is the question embedding, and x i  R  d is the hidden vector of word x i . d is the hidden dimension. Sketch Decoder. We use Gated Recurrent Unit (GRU) (Cho et al., 2014), a well-known variant of RNNs, as our decoder of program sketch. The decoding is conducted step by step. After we have predicted o t  1 , the hidden state of step t is computed as: h t = GRU ( h t  1 , o t  1 ) , (5) where h t  1 is the hidden state from last time step, o t  1 = [ W ] o t  1 denotes the embedding 8131 corresponding to o t  1 in the embedding matrix W  R |O| d . We use h t as the attention key to compute scores for each word in the question based on the hidden vector x i , and compute the attention vector c t as:  i = exp( x T i h t ) (cid:80) | x | j =1 exp( x T j h t ) , c t = | x | (cid:88) i =1  i x i . (6) The information of h t and c t are fused to predict the final probability of the next sketch token: g t = h t + c t , p ( o t | o <t , x ) = [ Softmax ( MLP ( g t ))] o t , (7) where MLP (short for multi-layer perceptron) projects  d -dimensional feature to |O| -dimension, which consists of two linear layers with ReLU activation. In the above section, the sketch is obtained with a sketch parser. In this section, we will introduce our argument parser, which aims to retrieve the argument arg t from the target KB for each function o t in the sketch. To reduce the search space, it retrieves arguments from a restricted candidate pool P , which is constructed with our ontology-guided pruning strategy. In the following, we will introduce the argument retrieval process and the candidate pool construction process. Argument Retrieval . Specifically, we take g t in Equation 7 as the context representation of o t , learn vector representation P i  R  d for each candidate P i , and calculate the probability for P i based on g t and P i . Candidate P i is encoded with the BERT encoder in Equation 4, which can be formulated as: P i = BERT ( P i ) . P i is the i th row of P . The probability of candidate arg t is calculated as: p ( arg t | x, o t , P ) = [ Softmax ( Pg t )] arg t . Candidate Pool Construction . In the following, we will introduce the KB ontology first. Then, we will describe the rationale of our ontology-guided pruning strategy and its implementation details. ontology. Specifically, a relation r comes with a domain dom ( r )  C and a range ran ( r )  C . An entity e comes with a type type ( e ) = { c | ( e, instanceOf , c )  T } . For example, as shown in Fig. 2, sports team owner  dom ( teams owned ) , sports team  ran ( teams owned ) , and sports team  type ( Baltimore Ravens ) . The rationale of our pruning is that the arguments for program functions are mutually constrained according to the KB ontology. Therefore, when the argument arg t for o t is determined, the possible candidates for { o i } | y s | i = t +1 will be adjusted. For example, in Fig. 2, when Relate takes teams owned as the argument, the candidate pool for the next FilterConcept is constrained to the range of relation teams owned , thus other concepts ( e.g. , time zone ) will be excluded from the candidate pool. In practice, we propose a set of ontology-oriented operators to adjust the candidate pool P step-by-step. Specifically, we define three ontology-oriented operators C ( e ) , R ( r ) , D  ( c ) , which aim to find the type of entity e , the range of relation r , and the relations whose domain contains c . Furthermore, we use the operators to maintain an entity pool PE , a relation pool PR and a concept pool PC . When arg t of o t is determined, we will update PE , PR , and PC using C ( e ) , R ( r ) , D  ( c ) . We take one of the three pools as P according to the argument type of o t . The detailed algorithm is shown in Appendix. We train our model using the popular pretrain-finetune paradigm. Specifically, we pretrain the parsers on the source domain data DS = (cid:8)(cid:0) x Si , y Si (cid:1)(cid:9) n S i =1 in a supervised way. After that, we conduct finetuning on the target domain data DT = (cid:8)(cid:0) x Ti , z Ti (cid:1)(cid:9) n T i =1 in a weakly supervised way. Pretraining in Source Domain. Since the source domain data provides complete annotations, we can directly maximize the log-likelihood of the golden sketch and golden arguments: L pretrain =  (cid:88) ( x S ,y S ) D S (cid:18) log p ( y S s | x S ) + | y s | (cid:88) t =1 log p ( arg St | x S , o St , P ) (cid:19) . (10) 8132 Finetuning in Target Domain. At this training phase, questions are labeled with answers while programs remain unknown. The basic idea is to search for potentially correct programs and optimize their corresponding probabilities. Specifically, we propose two training strategies:  Hard-EM Approach. At each training step, hard-EM generates a set of possible programs with beam search based on current model parameters, and then executes them to find the one whose answers have the highest F1 score compared with the gold. Let  y T denote the best program, we directly maximize p ( y T | x T ) like Equation 10. Reinforcement learning (RL). It formulates the program generation as a decision making procedure and computes the rewards for sampled programs based on their execution results. We take the F1 score between the executed answers and golden answers as the reward value, and use REINFORCE (Williams, 1992) algorithm to optimize the parsers. Source Domain. KQA Pro (Cao et al., 2022) provides 117,970 question-program pairs based on a Wikidata (Vrandecic and Krtzsch, 2014) subset. Target Domain. We use WebQuestionSP (We-bQSP) (Yih et al., 2016) and ComplexWebQuestions (CWQ) (Talmor and Berant, 2018) as the target domain datasets for two reasons: (1) They are two widely used benchmark datasets in Complex KBQA; (2) They are based on a large-scale KB Freebase (Bollacker et al., 2008), which makes program transfer challenging. Specifically, WebQSP contains 4,737 questions and is divided into 2,998 train, 100 dev and 1,639 test cases. CWQ is an extended version of WebQSP which is more challenging, with four types of questions: composition (44.7%), conjunction (43.6%), comparative (6.2%), and superlative (5.4%). CWQ is divided into 27,639 train, 3,519 dev and 3,531 test cases. We use the Freebase dump on 2015-08-09 1 , from which we extract the type of entities, domain and range of relations to construct the ontology. The average domain, range, type size is 1.43 per relation, 1.17 per relation, 8.89 per entity respectively. Table 2 shows the statistics of the source and target domain KB. The target domain KB contains much more KB elements, and most of them are uncovered by the source domain. In our experiments, we select representative models that learn from question-answer pairs as our baselines. They can be categorized into three groups: program induction methods, query graph generation methods and information retrieval methods. Existing program induction methods search for gold programs with RL. They usually require human efforts or are constrained to simple questions. NSM (Liang et al., 2017) uses the provided entity, relation and type annotations to ease the search, and can solve relatively simple questions. NPI (Ansari et al., 2019) designs heuristic rules such as disallowing repeating or useless actions for efficient search. Existing query graph generation methods generate query graphs whose execution on KBs produces the answer. They use entity-level triples as search guidance, ignoring the useful ontology. TEXTRAY (Bhutani et al., 2019) uses a decompose-execute-join approach. QGG (Lan and Jiang, 2020) incorporates constraints into query graphs in the early stage. TeacherNet (He et al., 2021) utilizes bidirectional searching. Existing information retrieval methods directly construct a question-specific sub-KB and then rank the entities in the sub-KB to get the answer. GraftNet (Sun et al., 2018) uses heuristics to create the subgraph and uses a variant of graph convolutional networks to rank the entities. PullNet (Sun et al., 2019) improves GraftNet by iteratively constructing the subgraph instead of using heuristics. Besides, we compare our full model Ours with Ours -f , Ours -p , Ours -pa , Ours -o , which denotes our model without finetuning, without pretraining, without pretraining of argument parser, and without our ontology-guided pruning strategy respectively. Following prior works (Berant et al., 2013; Sun et al., 2018; He et al., 2021), we use F1 score and Hit@1 as the evaluation metrics. Since questions in the datasets have multiple answers, F1 score reflects the coverage of predicted answers better. We used the bert-base-cased model of Hugging-Face 2 as our BERT encoder with the hidden dimension  d 768. The hidden dimension of the sketch decoder d was 1024. We used AdamW (Loshchilov and Hutter, 2019) as our optimizer. We searched the learning rate for BERT paramters in { 1e-4, 3e-5, 1e-5 } , the learning rate for other parameters in { 1e-3, 1e-4, 1e-5 } , and the weight decay in { 1e-4, 1e-5, 1e-6 } . According to the performance on dev set, we finally used learning rate 3e-5 for BERT parameters, 1e-3 for other parameters, and weight decay 1e-5. As shown in Table 3, our model achieves the best performance on both WebQSP and CWQ. Especially on CWQ, we have an absolute gain of 14.7% in F1 and 9.3% in Hit@1, beating previous methods by a large margin. Note that CWQ is much more challenging than WebQSP because it includes more compositional and conjunctional questions. Previous works mainly suffer from the huge search 2 https://github.com/huggingface/transformers space and sparse training signals. We alleviate these issues by transferring the prior knowledge from external annotations and incorporating the ontology guidance. Both of them reduce the search space substantially. On WebQSP, we achieve an absolute gain of 2.5% and 0.3% in F1 and Hit@1, respectively, demonstrating that our model can also handle simple questions well, and can adapt to different complexities of questions. Note that our F1 scores are higher than the corresponding Hit@1. This is because we just randomly sampled one answer from the returned answer set as the top 1 without ranking them. We utilize beam search to generate multiple possible programs and evaluate their performance. Table 4 shows the highest F1 score in the top-k generated programs, where top-1 is the same as Table 3. We can see that the best F1 in the top-10 programs is much higher than the F1 of the top-1 ( e.g. , with an absolute gain 10.4% for WebQSP and 6.3% for CWQ). This indicates that a good re-ranking method can further improve the overall performance of our model. We leave this as our future work. Pretraining: As shown in Table 3, when comparing Ours -pa with Ours, the F1 and Hit@1 on CWQ drop by 4 . 2% and 3 . 8% respectively, which indicates that the pretraining for the argument parser is necessary. Ours -p denotes the model without pretraining for neither sketch parser nor argument parser. We can see that its results are very poor, achieving just about 3% and 2% on WebQSP and CWQ, indicating that the pretraining is essential, especially for the sketch parser. Finetuning: Without finetuning on the target data, i.e. , in Ours -f , performance drops a lot compared with the complete model. For example, F1 and Hit@1 on CWQ drop by 12.8% and 12.9% respectively. It indicates that finetuning is necessary for the model's performance. As shown in Table 2, most of the relations and concepts in the target domain are uncovered by the source domain. Due to 8134 the semantic gap between source and target data, the prior knowledge must be properly transferred to the target domain to bring into full play. Ontology: We implemented Ours -o by removing ontology from KB and removing FilterConcept from the program. Comparing Ours -o with Ours, the F1 and Hit@1 on CWQ drops by 2.9% and 3.4% respectively, which demonstrates the importance of ontology-guided pruning strategy. We calculated the search space size for each compositional and conjunctive question in the dev set of CWQ, and report the average size in Table 5. The statistics shows that, the average search space size of Ours is only 0.26% and 3.2% of that in Ours -o for the two kinds of questions. By incorporating the ontology guidance, Ours substantially reduces the search space. Hard-EM v.s. RL: For both WebQSP and CWQ, training with Hard-EM achieves better performance. For RL, we simply employed the REINFORCE algorithm and did not implement any auxiliary reward strategy since this is not the focus of our work. The sparse, delayed reward causes high variance, instability, and local minima issues, making the training hard (Saha et al., 2019b). We leave exploring more complex training strategies as our future work. Fig. 3 gives a case, where our model parses an question into multiple programs along with their probablility scores and F1 scores of executed answers. Given the question  The person whose education institution is Robert G. Cole Junior-Senior High School played for what basketball teams? , we show the programs with the largest, 2-nd largest Find R.G.C. High School Relate [inv] educationinstitution Fil.Con. and 10-th largest possibility score. Both of the top-2 programs get the correct answer set and are semantically equivelant with the question, while the 10-th best program is wrong. Error Analysis We randomly sampled 100 error cases whose F1 score is lower than 0.1 for manual inspection. The errors can be summarized into the following categories: (1) Wrong relation (53%): wrongly predicted relation makes the program wrong, e.g. , for question  What language do people in the Central Western Time Zone speak? , our model predicts the relation main country , while the ground truth is countries spoken in ; (2) Wrong concept (38%): wrongly predicted concept makes the program wrong, e.g. , for the question  What continent does the leader Ovadia Yosel live in? , our model predicted the concept location , whereas the ground truth is continent . (3) Model limitation (9%): Handling attribute constraint was not considered in our model, e.g. , for the question  Who held his governmental position from before April 4, 1861 and influenced Whitman's poetry? , the time constraint April 4, 1861 cannot be handled. In this parper, we propose program transfer for Complex KBQA for the first time. We propose a novel two-stage parsing framework with an efficient ontology-guided pruning strategy. First, a sketch parser translates a question into the program, and then an argument parser fills in the detailed 8135 arguments for functions, whose search space is restricted by an ontology-guided pruning strategy. The experimental results demonstrate that our program transfer approach outperforms the previous methods significantly. The ablation studies show that our two-stage parsing paradigm and ontology-guided pruning are both effective. This work is founded by the National Key Research and Development Program of China (2020AAA0106501), the Institute for Guo Qiang, Tsinghua University (2019GQB0003), Huawei Noah's Ark Lab and Beijing Academy of Artificial Intelligence.
abstain abstain abstain objective objective abstain abstain abstain objective other abstain other abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain objective abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain objective objective abstain abstain abstain method abstain abstain objective abstain abstain abstain method result objective abstain abstain abstain other other other other other other other other other other other other other other other abstain abstain abstain abstain abstain other abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain other abstain method abstain abstain abstain abstain abstain abstain abstain method abstain abstain abstain abstain abstain abstain abstain method abstain method abstain abstain abstain method abstain method method other abstain abstain method abstain abstain method abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain method method method abstain method method method abstain method abstain abstain abstain abstain abstain abstain abstain abstain method abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain result abstain abstain other abstain abstain abstain abstain abstain abstain abstain result result abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain method abstain abstain abstain abstain abstain method abstain abstain abstain abstain abstain abstain method other method objective objective abstain objective result other