0
0

WebCPM：首个开源的交互式网页搜索中文问答模型

在这里插入图片描述

  论文题目：

  1. WEBCPM: Interactive Web Search for Chinese Long-form Question Answering

  论文日期：

  1. 2023/05/23(ACL 2023)

  论文地址：https://arxiv.org/abs/2305.06849

  1. GitHub

地址：https://arxiv.org/abs/2305.06849

文章目录

Abstract

  长文本问答

  1. (long-form question answering, LFQA)

旨在用详细的、分段式的回应来回答复杂的、开放式的问题。

  1. LFQA

的事实范式需要两个步骤：信息检索

  1. (information retrieval)

，搜索相关的支持事实，以及信息合成

  1. (information synthesis)

，将这些事实整合成一个连贯的答案。
  本文介绍了中国首个

  1. LFQA

数据集

  1. WebCPM

。

  1. WebCPM

的一个独特之处在于它的信息检索是基于交互式网络搜索的，它实时地与搜索引擎进行交互。仿照

  1. WebGPT

，作者开发了一个网页搜索界面，招募一些标注员，使用这个界面搜索相关信息，然后回答问题。同时，标注员的网页搜索行为会被记录下来。作者总共收集了

  1. 5500

个高质量的问答对，以及

  1. 15372

个支持事实

  1. (supporting facts)

和

  1. 125954

个网页搜索行为。对预训练的语言模型进行微调，以模仿人类的网页搜索行为，并根据收集到的事实生成答案。

  1. LFQA pipeline

建立在这些微调模型的基础上，在数据集

  1. WebCPM

和

  1. DuReader

上分别有

  1. 32.5%

和

  1. 47.5%

的情况下，生成的答案并不比人类编写的答案差。

1. Introduction

  1. LFQA

的目标是用详细的、段落长度的回答回答复杂的、开放式的问题。当前的

  1. LFQA

解决方案一般遵循

  1. retrieve-then-synthesize

范式，该范式包括两个核心成分：

  1. (information retrieval)

和

  1. (information synthesis)

。前者搜索外部知识源

  1. (e.g., the web)

以获得多样性相关的支持性事实，后者将收集到的事实整合成一个连贯的答案。
  传统

  1. LFQA

范式的一个缺陷是，它经常采用非交互式

  1. (non-interactive)

检索方法，即使用原始问题作为查询来检索一堆未经整理的信息。相反，人类能够通过与搜索引擎实时互动来执行交互式网页搜索

  1. (interactive web search)

。对于一个复杂的问题，人类倾向于将其分解为多个子问题，并依次提问。通过识别和浏览相关信息，人类可以提高对主题的理解，并通过提出后续问题或相关术语来完善搜索。这种迭代的过程能够扩大他们的搜索范围，并改善他们得到的结果。总的来说，交互式的网络搜索不仅提供了对多样化信息源的访问，而且反映了人类如何解决问题的认知过程，这就有了更好的可解释性。

  1. 2021

年底

  1. OpenAI

发布的

  1. WebGPT

是支持

  1. LFQA

交互式网页搜索的先驱工作。作者首先构建了一个由

  1. Microsoft Bing

支持的网页搜索界面，然后招募标注员使用该界面收集信息来回答问题之后，他们对

  1. GPT-3

进行微调，以模仿人类的网页搜索行为，并将收集到的信息组织成答案。在实验中，

  1. WebGPT

在

  1. LFQA

方面表现出了超群的能力，甚至超过了人类专家。尽管具有令人印象深刻的性能，但

  1. WebGPT

对大部人研究员们来说依然是个黑盒模型。这是因为

  1. WebGPT

的接口、数据集和训练模型都没有开源，而且其核心设计元素的内部工作也不透明。这些因素使得该领域研究员很难理解

  1. LFQA

交互式网页搜索的挑战，也很难继续探索这一研究方向。
  鉴于此，作者认为迫切需要在这方面提供一个无障碍的平台和公众基准。为此，首先构建了一个界面

  1. (Figure 1)

来记录人类收集长文本问题相关信息时的网络搜索行为。在界面中用户可以执行预定义的动作，进行多轮的搜索和浏览。当在网页上找到相关信息时，他们可以将其记录为支持事实。同时，他们的上网行为也会被记录下来。在收集到足够的信息后，用户可以完成网络搜索，并根据收集到的事实回答问题。

在这里插入图片描述
  在界面的基础上，选择中文作为测试平台构建

  1. WebCPM

，重点研究中文预训练模型的交互式

  1. Web

搜索。

  1. WebCPM

是第一个涉及交互式网络搜索的公共

  1. QA

数据集，也是第一个针对中国

  1. LFOA

的数据集。

  1. WebCPM

包含

  1. 5500

个问答对，

  1. 15372

个支持事实和

  1. 125954

个网络搜索动作。下表()总结了

  1. WebCPM

和相关

  1. QA

数据集之间的差异。在现有的中文

  1. QA

数据集中

  1. WebCPM

拥有最长的问题、支持事实和答案这表明问题的复杂性和注释答案的丰富性。

在这里插入图片描述
  然后，提出了一个通用框架，包括：

  1. (1)

一个模仿人类网页搜索行为的搜索模型

  1. (search model)

，用于信息检索。具体来说，搜索模型包含三个模块，在界面上执行一系列预定义的动作：一个动作预测模块

  1. (action prediction module)

，一个搜索查询生成模块

  1. (search query generation module)

和一个支持事实提取模块

  1. (supporting fact extraction module)

；

  1. (2)

一个合成模型

  1. (synthesis model)

，用来将收集到的事实为条件，生成连贯的答案。
  作者选择了

  1. 8

个具有代表性的预训练语言模型

  1. (PLMs)

，参数规模高达

  1. 10B

，并评估了它们的交互式

  1. web

搜索和信息合成能力。作者发现，扩展模型大小对实现更好的性能至关重要。通过为搜索和合成模型选择性能最好的骨干

  1. PLM

，将它们组合成一个整体的

  1. LFQA pipeline

，并将其能力与人类进行比较。人工评估显示，

  1. LFQA pipeline

在

  1. WebPCM

测试集上有

  1. 32.5%

的情况下生成的答案不逊于人类。当应用于百度的

  1. DuReader

数据集(标注答案超过400个汉字的问题)时，

  1. LFQA pipeline

在47.5%的情况下生成的答案优于黄金标注的答案，显示出令人满意的分布外泛化性能。实验还表明，作者的搜索模型超越了传统的非交互式检索方法。

2. Related Work

2.1 Retrieval and Synthesis in LFQA

  对于信息检索，之前的工作通常求助于本地存储库(如维基百科)。最近，人们对利用整个网络作为知识源的兴趣激增，这不仅拓宽了信息源的范围，而且使最新知识的实时覆盖成为可能。另一方面如何将检索到的事实组织成

  1. LFQA

的合理而微妙的答案仍有待探索。一些人研究了人类如何制造复杂的答案，要么通过研究长文本答案的功能结构，要么探索如何在答案中组合例证，其他人则重新审视现有的

  1. LFQA

评估指标。

2.2 Comparison with WebGPT

  作者在很大程度上遵循了

  1. WebGPT

，并提出了改进的设计元素

  1. (appendix E)

，包括：

  1. (1)
  1. interface:

修改了

  1. WebGPT

定义的动作，使其更容易模型学习，更方便用户使用；

  1. (2)
  1. framework:

将

  1. web

搜索分解为3个子任务并实现模块化搜索模型。此外，还探索了如何教合成模型忽略无关事实并生成新颖内容；

  1. (3)
  1. evaluation and analysis:

除了评估

  1. WebGPT

之后的整个

  1. pipeline

外，还评估每个单独的模块。这种细粒度的评估帮助我们更好地理解这个框架的核心设计元素，以及模型学习到的人类行为。

2.3 Tool Learning

  最近的研究表明，

  1. PLMs

具有操作工具的潜力，即工具学习

  1. (tool learning)

，

  1. PLMs

可以在复杂的交互环境中做出顺序决策，例如机器人任务的规划，操纵搜索引擎，在电子商务网站上购物等。通过利用在预训练期间学到的丰富世界知识，

  1. PLMs

可以执行与现实世界交互的基础操作。作者设想将这个基准作为未来在这一领域探索的测试平台。

3. Web Search Environment

  仿照

  1. WebGPT

，作者构建了一个纯文本界面以记录人类在为长文本问题收集相关信息时的网页搜索行为。该界面由

  1. Bing Search API

支持，支持

  1. 10

种主流的网页搜索动作，如

  1. (Figure 1)

所示。当一个动作被执行时，这个界面会在窗口中做出响应。
  当执行

  1. Search

动作时，界面进入

  1. search mode
  1. (Figure 1)

，它显示

  1. Bing

为特定查询

  1. <query>

推荐的链接。每个链接由一个标题和一个特定网页的简短快照组成。每个窗口一次显示三个链接，通过执行

  1. Scroll Down

动作可以访问更多链接。
  当在当前窗口中找到第

  1. i

个相关链接时，用户可以执行

  1. Load Page <i>

动作。界面将进入浏览模式

  1. (browsing mode)
  1. (Figure 6)

，并呈现从第

  1. <i>

个网页的

  1. HTML

中清理出来的文本。用户在窗口中一次可以查看的内容被限制在500个汉字以内，通过

  1. Scroll

动作可以访问更多的内容。用户可以利用

  1. Quote

动作提取当前窗口中连续的句子作为支持事实。为了能够提取横跨两个窗口的文本，

  1. Merge

动作旨在将最后两个事实合并为一个事实。同时还为用户展示了所有现有的提取出来的支持事实。
  在浏览第

  1. i

个页面后，用户可以使用

  1. Go Back

动作返回到以前的搜索模式来访问其他链接。同时，可以随时发送精细化的查询。一般来说用户可以多次自由地与界面进行交互直到执行

  1. Finish

动作或触发最大动作数量(例子中是100个)。该界面将自动记录在网页搜索过程中有意义的行为和观察。由于

  1. Bing

系统的多语言特性，虽然本工作的重点是中文，但这个界面也可以灵活地适应其他语言。有关更多技术细节，请参阅

  1. appendix A

。

4. Data Collection

  作者雇佣了

  1. 23

位来自不同行业的标注员，他们都有丰富的搜索引擎使用经验。要求他们回答长文本问题，首先使用这个界面搜索相关信息，然后写出正确且合理的答案。在质量控制方面，聘请了

  1. 8

名熟悉

  1. QA

研究的专家作为质量检验员。接下来，介绍数据集的构建过程，详细的注释指南留在

  1. appendix B

。

4.1 Question Creation

  在没有任何参考的情况下从零开始创建新的长文本问题代价较大，因此转向公共

  1. QA

论坛作为问题来源。具体来说，让标注员参考英语

  1. QA

论坛

  1. Reddit

上的问题，然后用中文编写新的问题。这个创建过程的细节在附录

  1. appendix C

中详细阐述。从经验上发现，以这种方式创建的问题往往需要多轮搜索和浏览，以收集足够的信息。

4.2 Interactive Web Search

  给定一个问题，要求标注员使用这个界面从可信来源搜索准确和相关的信息。这个过程可能包括多次

  1. Bing

应发送精炼的查询，以及探索他们认为相关的各种网页。要求标注员在提取信息作为支持事实之前仔细判断信息的事实准确性，直到收集到足够的支持事实，搜索过程才结束。在创建的问题中，有

  1. 26.2%

是无法回答的，最终被丢弃，因为标注员无法找到足够的有用信息。

4.3 Answer Annotation

  在收集到足够的支持事实后，标注员会根据他们收集的信息写出合理的答案。作者为他们提供答案注释的指导，包括编写与问题相关且内容丰富的答案，保持逻辑的一致性、清晰性和连贯性，并以公正的方式提供观点。

4.4 Quality Control

  每个标注实例在被选择为最终数据集之前都要经过质量检查员的检查和批准。首先，检查人员将手动检查界面上记录的动作序列，并丢弃低质量的动作序列(例如，在其发出的查询中有明显的书写错误的那些)；其次，他们将仔细检查收集到的支持事实，如果这些事实显然不足以回答问题，或与问题无关，或者事实不正确，相应的行动序列就会被放弃，上述程序会移除

  1. 25%

收集到的实例。对于剩余的实例，检查人员会仔细检查他们带注释的答案。如果一个答案与上述说明相矛盾，检查人员会将其返回给标注员，并指出哪个要求不满足。标注员可能会多轮修改他们的答案，直到修改后的答案达到标准。

4.5 Dataset Statistics

  最终，作者收集到了

  1. 5500

个实例，每个实例格式化为元组

  1. (question, web search behavior, supporting fact, answer)

，还记录了每个动作执行时的观察结果。在

  1. (Figure 2)

中展示了一个示例以供参考，其中呈现了以下内容原始的问题、简化的动作序列、收集到的支持事实以及标注的答案。将数据集划分为

  1. {4700,400,400}

，作为训练、开发和测试集。平均来说，每个问题涉及执行

  1. 22.9

个搜索动作，发送

  1. 2.5

个查询，加载

  1. 3.3

个网页。每个动作的详细比例可视化图可参见

  1. (Figure 7)

。

在这里插入图片描述
在这里插入图片描述

5. Framework

5.1 Search Model

  将

  1. web

搜索划分为3个子任务：

  1. action prediction

，

  1. search query generation

和 

  1. supporting fact extraction

。每个任务都被转换为

  1. text-to-text

的格式，使用生成式

  1. PLM

训练3个单独的模块。通过组合这3个模块，构建了搜索模型，该模型执行一系列动作来收集相关信息。

  1. action prediction

模块决定每一步执行哪个动作，如果该模块预测

  1. Search

或

  1. Quote

为当前动作，然后它调用其他两个模块来生成查询的内容或支持事实。
  每个模块根据时间步长 

  1.      t 
  2.     
  3.    
  4.   
  5.     t 
  6.    
  7.   
  8. t 时接口的当前状态  
  9.  
  10.   
  11.    
  12.     
  13.     
  14.       S 
  15.      
  16.     
  17.       t 
  18.      
  19.     
  20.    
  21.   
  22.     \mathcal S_t 
  23.    
  24.   
  25. St​来执行推理。 
  26.  
  27.   
  28.    
  29.     
  30.     
  31.       S 
  32.      
  33.     
  34.       t 
  35.      
  36.     
  37.    
  38.   
  39.     \mathcal S_t 
  40.    
  41.   
  42. St​ 包含原始问题  
  43.  
  44.   
  45.    
  46.     
  47.     
  48.       Q 
  49.      
  50.     
  51.       0 
  52.      
  53.     
  54.    
  55.   
  56.     \mathcal Q_0 
  57.    
  58.   
  59. Q0​，当前搜索的查询  
  60.  
  61.   
  62.    
  63.     
  64.     
  65.       Q 
  66.      
  67.     
  68.       t 
  69.      
  70.     
  71.    
  72.   
  73.     \mathcal Q_t 
  74.    
  75.   
  76. Qt​，过去的动作序列  
  77.  
  78.   
  79.    
  80.     
  81.     
  82.       A 
  83.      
  84.      
  85.      
  86.        t 
  87.       
  88.      
  89.        − 
  90.       
  91.      
  92.        1 
  93.       
  94.      
  95.     
  96.    
  97.      = 
  98.     
  99.    
  100.      { 
  101.     
  102.     
  103.     
  104.       a 
  105.      
  106.     
  107.       1 
  108.      
  109.     
  110.    
  111.      , 
  112.     
  113.    
  114.      … 
  115.     
  116.    
  117.      , 
  118.     
  119.     
  120.     
  121.       a 
  122.      
  123.      
  124.      
  125.        t 
  126.       
  127.      
  128.        − 
  129.       
  130.      
  131.        1 
  132.       
  133.      
  134.     
  135.    
  136.      } 
  137.     
  138.    
  139.   
  140.     \mathcal A_{t-1} = \{a_1, \dots, a_{t-1}\} 
  141.    
  142.   
  143. At−1​={a1​,…,at−1​}，上一个和当前窗口中显示的内容  
  144.  
  145.   
  146.    
  147.     
  148.     
  149.       W 
  150.      
  151.      
  152.      
  153.        t 
  154.       
  155.      
  156.        − 
  157.       
  158.      
  159.        1 
  160.       
  161.      
  162.     
  163.    
  164.   
  165.     \mathcal W_{t-1} 
  166.    
  167.   
  168. Wt−1​和  
  169.  
  170.   
  171.    
  172.     
  173.     
  174.       W 
  175.      
  176.     
  177.       t 
  178.      
  179.     
  180.    
  181.   
  182.     \mathcal W_t 
  183.    
  184.   
  185. Wt​，当前支持事实  
  186.  
  187.   
  188.    
  189.     
  190.     
  191.       F 
  192.      
  193.     
  194.       t 
  195.      
  196.     
  197.    
  198.      = 
  199.     
  200.    
  201.      { 
  202.     
  203.     
  204.     
  205.       f 
  206.      
  207.     
  208.       1 
  209.      
  210.     
  211.    
  212.      , 
  213.     
  214.    
  215.      … 
  216.     
  217.    
  218.      , 
  219.     
  220.     
  221.     
  222.       f 
  223.      
  224.      
  225.      
  226.        ∣ 
  227.       
  228.       
  229.       
  230.         F 
  231.        
  232.       
  233.         t 
  234.        
  235.       
  236.      
  237.        ∣ 
  238.       
  239.      
  240.     
  241.    
  242.      } 
  243.     
  244.    
  245.   
  246.     \mathcal F_t = \{f_1, \dots, f_{|\mathcal F_t|}\} 
  247.    
  248.   
  249. Ft​={f1​,…,f∣Ft​∣​}，以及剩余动作数。如果执行一个动作，则  
  250.  
  251.   
  252.    
  253.     
  254.     
  255.       S 
  256.      
  257.     
  258.       t 
  259.      
  260.     
  261.    
  262.   
  263.     S_t 
  264.    
  265.   
  266. St​ 的组件将被更新， 
  267.  
  268.   
  269.    
  270.    
  271.      W 
  272.     
  273.    
  274.   
  275.     \mathcal W 
  276.    
  277.   
  278. W 可以是搜索模式
  1. (search mode)

下的三个链接，也可以是

  1. (browsing mode)

下的特定页面内容，只保持最近的两个观察结果 

  1.       W 
  2.      
  3.      
  4.      
  5.        t 
  6.       
  7.      
  8.        − 
  9.       
  10.      
  11.        1 
  12.       
  13.      
  14.     
  15.    
  16.   
  17.     \mathcal W_{t-1} 
  18.    
  19.   
  20. Wt−1​和  
  21.  
  22.   
  23.    
  24.     
  25.     
  26.       W 
  27.      
  28.     
  29.       t 
  30.      
  31.     
  32.    
  33.   
  34.     \mathcal W_t 
  35.    
  36.   
  37. Wt​ 显示在窗口中，而不是将所有过去的观察结果串联起来，因为后者可能超过
  1. PLM

的输入长度限制。

5.1.1 Action Prediction

  这个模块预测接下来要执行的动作。由于总共有10个可能的动作，动作预测可以被视为10类别的分类任务。以

  1. Search

动作为例，用 

  1.      { 
  2.     
  3.     
  4.     
  5.       x 
  6.      
  7.     
  8.       1 
  9.      
  10.     
  11.    
  12.      , 
  13.     
  14.    
  15.      … 
  16.     
  17.    
  18.      , 
  19.     
  20.     
  21.     
  22.       x 
  23.      
  24.     
  25.       n 
  26.      
  27.     
  28.    
  29.      } 
  30.     
  31.    
  32.   
  33.     \{x_1, \dots, x_n\} 
  34.    
  35.   
  36. {x1​,…,xn​} 表示作为
  1. Search

动作的标记化序列，其中 

  1.      x 
  2.     
  3.    
  4.      ∗ 
  5.     
  6.    
  7.   
  8.     x* 
  9.    
  10.   
  11. x∗ 表示一个特定的标记
  1. (token)

。

  1. Search

的概率可以用公式表示为 

  1.       P 
  2.      
  3.     
  4.       ( 
  5.      
  6.     
  7.       S 
  8.      
  9.     
  10.       e 
  11.      
  12.     
  13.       a 
  14.      
  15.     
  16.       r 
  17.      
  18.     
  19.       c 
  20.      
  21.     
  22.       h 
  23.      
  24.     
  25.       ∣ 
  26.      
  27.      
  28.      
  29.        S 
  30.       
  31.      
  32.        t 
  33.       
  34.      
  35.     
  36.       ) 
  37.      
  38.     
  39.       = 
  40.      
  41.     
  42.       P 
  43.      
  44.     
  45.       ( 
  46.      
  47.      
  48.      
  49.        x 
  50.       
  51.      
  52.        1 
  53.       
  54.      
  55.     
  56.       ∣ 
  57.      
  58.      
  59.      
  60.        S 
  61.       
  62.      
  63.        t 
  64.       
  65.      
  66.     
  67.       ) 
  68.      
  69.     
  70.       × 
  71.      
  72.      
  73.      
  74.        ∏ 
  75.       
  76.       
  77.       
  78.         i 
  79.        
  80.       
  81.         = 
  82.        
  83.       
  84.         2 
  85.        
  86.       
  87.      
  88.        N 
  89.       
  90.      
  91.     
  92.       P 
  93.      
  94.     
  95.       ( 
  96.      
  97.      
  98.      
  99.        x 
  100.       
  101.      
  102.        i 
  103.       
  104.      
  105.     
  106.       ∣ 
  107.      
  108.      
  109.      
  110.        S 
  111.       
  112.      
  113.        t 
  114.       
  115.      
  116.     
  117.       , 
  118.      
  119.      
  120.      
  121.        x 
  122.       
  123.      
  124.        1 
  125.       
  126.      
  127.     
  128.       , 
  129.      
  130.     
  131.       . 
  132.      
  133.     
  134.       . 
  135.      
  136.     
  137.       . 
  138.      
  139.     
  140.       , 
  141.      
  142.      
  143.      
  144.        x 
  145.       
  146.       
  147.       
  148.         i 
  149.        
  150.       
  151.         − 
  152.        
  153.       
  154.         1 
  155.        
  156.       
  157.      
  158.     
  159.       ) 
  160.      
  161.     
  162.    
  163.      \mathcal P(Search | \mathcal S_t) = \mathcal P(x_1 | \mathcal S_t) \times \prod _{i=2} ^N \mathcal P(x_i | \mathcal S_t, x_1, ..., x_{i−1}) 
  164.     
  165.    
  166.  P(Search∣St​)=P(x1​∣St​)×i=2∏N​P(xi​∣St​,x1​,...,xi−1​)  在推理过程中，选择具有最高概率的动作在界面上执行。

5.1.2 Search Query Generation

  这个模块生成一个查询 

  1.       Q 
  2.      
  3.      
  4.      
  5.        t 
  6.       
  7.      
  8.        + 
  9.       
  10.      
  11.        1 
  12.       
  13.      
  14.     
  15.    
  16.      = 
  17.     
  18.    
  19.      { 
  20.     
  21.     
  22.     
  23.       q 
  24.      
  25.     
  26.       1 
  27.      
  28.     
  29.    
  30.      , 
  31.     
  32.    
  33.      … 
  34.     
  35.    
  36.      , 
  37.     
  38.     
  39.     
  40.       q 
  41.      
  42.     
  43.       n 
  44.      
  45.     
  46.    
  47.      } 
  48.     
  49.    
  50.   
  51.     \mathcal Q_{t+1} = \{q_1, \dots, q_n\} 
  52.    
  53.   
  54. Qt+1​={q1​,…,qn​}来进行
  1. Bing

搜索，也可以用下述公式表示 

  1.       P 
  2.      
  3.     
  4.       ( 
  5.      
  6.      
  7.      
  8.        Q 
  9.       
  10.       
  11.       
  12.         t 
  13.        
  14.       
  15.         + 
  16.        
  17.       
  18.         1 
  19.        
  20.       
  21.      
  22.     
  23.       ∣ 
  24.      
  25.      
  26.      
  27.        S 
  28.       
  29.      
  30.        t 
  31.       
  32.      
  33.     
  34.       ) 
  35.      
  36.     
  37.       = 
  38.      
  39.     
  40.       P 
  41.      
  42.     
  43.       ( 
  44.      
  45.      
  46.      
  47.        q 
  48.       
  49.      
  50.        1 
  51.       
  52.      
  53.     
  54.       ∣ 
  55.      
  56.      
  57.      
  58.        S 
  59.       
  60.      
  61.        t 
  62.       
  63.      
  64.     
  65.       ) 
  66.      
  67.     
  68.       × 
  69.      
  70.      
  71.      
  72.        ∏ 
  73.       
  74.       
  75.       
  76.         i 
  77.        
  78.       
  79.         = 
  80.        
  81.       
  82.         2 
  83.        
  84.       
  85.       
  86.       
  87.         ∣ 
  88.        
  89.        
  90.        
  91.          Q 
  92.         
  93.         
  94.         
  95.           t 
  96.          
  97.         
  98.           + 
  99.          
  100.         
  101.           1 
  102.          
  103.         
  104.        
  105.       
  106.         ∣ 
  107.        
  108.       
  109.      
  110.     
  111.       P 
  112.      
  113.     
  114.       ( 
  115.      
  116.      
  117.      
  118.        q 
  119.       
  120.      
  121.        i 
  122.       
  123.      
  124.     
  125.       ∣ 
  126.      
  127.      
  128.      
  129.        S 
  130.       
  131.      
  132.        t 
  133.       
  134.      
  135.     
  136.       , 
  137.      
  138.      
  139.      
  140.        q 
  141.       
  142.      
  143.        1 
  144.       
  145.      
  146.     
  147.       , 
  148.      
  149.     
  150.       . 
  151.      
  152.     
  153.       . 
  154.      
  155.     
  156.       . 
  157.      
  158.     
  159.       , 
  160.      
  161.      
  162.      
  163.        q 
  164.       
  165.       
  166.       
  167.         i 
  168.        
  169.       
  170.         − 
  171.        
  172.       
  173.         1 
  174.        
  175.       
  176.      
  177.     
  178.       ) 
  179.      
  180.     
  181.    
  182.      \mathcal P(Q_{t+1} | \mathcal S_t) = \mathcal P(q_1 | \mathcal S_t) \times \prod _{i=2} ^{|Q_{t+1}|} \mathcal P(q_i | \mathcal S_t, q_1, ..., q_{i−1}) 
  183.     
  184.    
  185.  P(Qt+1​∣St​)=P(q1​∣St​)×i=2∏∣Qt+1​∣​P(qi​∣St​,q1​,...,qi−1​)

5.1.3 Supporting Fact Extraction

  假设在

  1. browsing mode

下，当前窗口的内容是 

  1.       W 
  2.      
  3.     
  4.       t 
  5.      
  6.     
  7.    
  8.      = 
  9.     
  10.    
  11.      { 
  12.     
  13.     
  14.     
  15.       w 
  16.      
  17.     
  18.       1 
  19.      
  20.     
  21.    
  22.      , 
  23.     
  24.    
  25.      … 
  26.     
  27.    
  28.      , 
  29.     
  30.     
  31.     
  32.       w 
  33.      
  34.      
  35.      
  36.        ∣ 
  37.       
  38.       
  39.       
  40.         W 
  41.        
  42.       
  43.         t 
  44.        
  45.       
  46.      
  47.        ∣ 
  48.       
  49.      
  50.     
  51.    
  52.      } 
  53.     
  54.    
  55.   
  56.     \mathcal W_t = \{w_1, \dots, w_{| \mathcal W_t|}\} 
  57.    
  58.   
  59. Wt​={w1​,…,w∣Wt​∣​}。目的是从  
  60.  
  61.   
  62.    
  63.     
  64.     
  65.       W 
  66.      
  67.     
  68.       t 
  69.      
  70.     
  71.    
  72.   
  73.     \mathcal W_t 
  74.    
  75.   
  76. Wt​ 中提取一个支持事实  
  77.  
  78.   
  79.    
  80.    
  81.      f 
  82.     
  83.    
  84.      = 
  85.     
  86.    
  87.      { 
  88.     
  89.     
  90.     
  91.       w 
  92.      
  93.     
  94.       i 
  95.      
  96.     
  97.    
  98.      , 
  99.     
  100.    
  101.      … 
  102.     
  103.    
  104.      , 
  105.     
  106.     
  107.     
  108.       w 
  109.      
  110.     
  111.       j 
  112.      
  113.     
  114.    
  115.      } 
  116.     
  117.    
  118.   
  119.     f = \{w_i, \dots, w_j\} 
  120.    
  121.   
  122. f={wi​,…,wj​}，其中 
  123.  
  124.   
  125.    
  126.    
  127.      1 
  128.     
  129.    
  130.      ≤ 
  131.     
  132.    
  133.      i 
  134.     
  135.    
  136.      ≤ 
  137.     
  138.    
  139.      j 
  140.     
  141.    
  142.      ≤ 
  143.     
  144.    
  145.      ∣ 
  146.     
  147.     
  148.     
  149.       W 
  150.      
  151.     
  152.       t 
  153.      
  154.     
  155.    
  156.      ∣ 
  157.     
  158.    
  159.   
  160.     1 \leq i \leq j \leq | \mathcal W_t| 
  161.    
  162.   
  163. 1≤i≤j≤∣Wt​∣。虽然一个朴素的解决方案是直接自动回归生成  
  164.  
  165.   
  166.    
  167.    
  168.      f 
  169.     
  170.    
  171.   
  172.     f 
  173.    
  174.   
  175. f 的所有
  1. token

，但这种解决方案在实践中存在推理速度慢的问题。作为一种替代方案，只生成给定 

  1.       S 
  2.      
  3.     
  4.       t 
  5.      
  6.     
  7.    
  8.   
  9.     \mathcal S_t 
  10.    
  11.   
  12. St​ 的前几个和最后几个
  1. token

，形式上，最大化 

  1.      P 
  2.     
  3.    
  4.      ( 
  5.     
  6.    
  7.      [ 
  8.     
  9.    
  10.      s 
  11.     
  12.    
  13.      ] 
  14.     
  15.    
  16.      , 
  17.     
  18.     
  19.     
  20.       w 
  21.      
  22.     
  23.       i 
  24.      
  25.     
  26.    
  27.      , 
  28.     
  29.    
  30.      … 
  31.     
  32.    
  33.      , 
  34.     
  35.     
  36.     
  37.       w 
  38.      
  39.      
  40.      
  41.        i 
  42.       
  43.      
  44.        + 
  45.       
  46.       
  47.       
  48.         N 
  49.        
  50.       
  51.         f 
  52.        
  53.       
  54.      
  55.        − 
  56.       
  57.      
  58.        1 
  59.       
  60.      
  61.     
  62.    
  63.      , 
  64.     
  65.    
  66.      [ 
  67.     
  68.    
  69.      e 
  70.     
  71.    
  72.      ] 
  73.     
  74.    
  75.      , 
  76.     
  77.     
  78.     
  79.       w 
  80.      
  81.      
  82.      
  83.        i 
  84.       
  85.      
  86.        + 
  87.       
  88.       
  89.       
  90.         N 
  91.        
  92.       
  93.         f 
  94.        
  95.       
  96.      
  97.        + 
  98.       
  99.      
  100.        1 
  101.       
  102.      
  103.     
  104.    
  105.      , 
  106.     
  107.    
  108.      … 
  109.     
  110.    
  111.      , 
  112.     
  113.     
  114.     
  115.       w 
  116.      
  117.     
  118.       j 
  119.      
  120.     
  121.    
  122.      ∣ 
  123.     
  124.     
  125.     
  126.       S 
  127.      
  128.     
  129.       t 
  130.      
  131.     
  132.    
  133.      ) 
  134.     
  135.    
  136.   
  137.     \mathcal P ( [s], w_i, \dots, w_{i+N_f -1}, [e], w_{i+N_f +1}, \dots, w_j | \mathcal S_t) 
  138.    
  139.   
  140. P([s],wi​,…,wi+Nf​−1​,[e],wi+Nf​+1​,…,wj​∣St​)，其中  
  141.  
  142.   
  143.    
  144.    
  145.      [ 
  146.     
  147.    
  148.      s 
  149.     
  150.    
  151.      ] 
  152.     
  153.    
  154.   
  155.     [s] 
  156.    
  157.   
  158. [s] 和  
  159.  
  160.   
  161.    
  162.    
  163.      [ 
  164.     
  165.    
  166.      e 
  167.     
  168.    
  169.      ] 
  170.     
  171.    
  172.   
  173.     [e] 
  174.    
  175.   
  176. [e] 表示事实  
  177.  
  178.   
  179.    
  180.    
  181.      f 
  182.     
  183.    
  184.   
  185.     f 
  186.    
  187.   
  188. f 的开始和结束的特殊
  1. token

。在推理过程中，在解码开始和结束标记后，可以通过文本匹配在 

  1.       W 
  2.      
  3.     
  4.       t 
  5.      
  6.     
  7.    
  8.   
  9.     \mathcal W_t 
  10.    
  11.   
  12. Wt​ 中找到所需的序列。如果起始/结束
  1. token

出现在 

  1.       W 
  2.      
  3.     
  4.       t 
  5.      
  6.     
  7.    
  8.   
  9.     \mathcal W_t 
  10.    
  11.   
  12. Wt​ 的多个位置，则总是从  
  13.  
  14.   
  15.    
  16.     
  17.     
  18.       W 
  19.      
  20.     
  21.       t 
  22.      
  23.     
  24.    
  25.   
  26.     \mathcal W_t 
  27.    
  28.   
  29. Wt​ 中提取最长的序列，一个大的  
  30.  
  31.   
  32.    
  33.     
  34.     
  35.       N 
  36.      
  37.     
  38.       f 
  39.      
  40.     
  41.    
  42.   
  43.     N_f 
  44.    
  45.   
  46. Nf​ 可以降低这种多位置问题的频率。注意，可以通过连续执行多个
  1. Quote

动作来提取 

  1.       W 
  2.      
  3.     
  4.       t 
  5.      
  6.     
  7.    
  8.   
  9.     \mathcal W_t 
  10.    
  11.   
  12. Wt​ 中的不相交跨度。

5.2 Synthesis Model

  信息合成任务学习将一系列支持性事实组织成一个连贯的答案。然而，训练好的搜索模型并不像人类那样完美，它偶尔会收集不相关的噪声，这会影响生成答案的质量。为了补救这一点，通过引入噪声来破坏合成模型的训练数据中收集的事实。具体来说，给定一系列人类提取的事实 

  1.      { 
  2.     
  3.     
  4.     
  5.       f 
  6.      
  7.     
  8.       1 
  9.      
  10.     
  11.    
  12.      , 
  13.     
  14.    
  15.      … 
  16.     
  17.    
  18.      , 
  19.     
  20.     
  21.     
  22.       f 
  23.      
  24.     
  25.       N 
  26.      
  27.     
  28.    
  29.      } 
  30.     
  31.    
  32.   
  33.     \{f_1, \dots, f_N\} 
  34.    
  35.   
  36. {f1​,…,fN​}，随机从其他训练实例中选取了一些不相关的事实  
  37.  
  38.   
  39.    
  40.    
  41.      { 
  42.     
  43.     
  44.     
  45.       f 
  46.      
  47.     
  48.       1 
  49.      
  50.     
  51.       ′ 
  52.      
  53.     
  54.    
  55.      , 
  56.     
  57.    
  58.      … 
  59.     
  60.    
  61.      , 
  62.     
  63.     
  64.     
  65.       f 
  66.      
  67.      
  68.      
  69.        N 
  70.       
  71.      
  72.        ′ 
  73.       
  74.      
  75.     
  76.       ′ 
  77.      
  78.     
  79.    
  80.      } 
  81.     
  82.    
  83.   
  84.     \{f_1', \dots, f_{N'}'\} 
  85.    
  86.   
  87. {f1′​,…,fN′′​}，将所有事实随机打乱后，将它们连接起来作为最终的输入。在训练过程中，对模型进行优化，以生成基于错误支持事实的人工注释答案，即最大化  
  88.  
  89.   
  90.    
  91.    
  92.      P 
  93.     
  94.    
  95.      ( 
  96.     
  97.    
  98.      A 
  99.     
  100.    
  101.      n 
  102.     
  103.    
  104.      s 
  105.     
  106.    
  107.      w 
  108.     
  109.    
  110.      e 
  111.     
  112.    
  113.      r 
  114.     
  115.    
  116.      ∣ 
  117.     
  118.     
  119.     
  120.       Q 
  121.      
  122.     
  123.       0 
  124.      
  125.     
  126.    
  127.      , 
  128.     
  129.     
  130.     
  131.       f 
  132.      
  133.     
  134.       1 
  135.      
  136.     
  137.    
  138.      , 
  139.     
  140.    
  141.      … 
  142.     
  143.    
  144.      , 
  145.     
  146.     
  147.     
  148.       f 
  149.      
  150.     
  151.       N 
  152.      
  153.     
  154.    
  155.      , 
  156.     
  157.     
  158.     
  159.       f 
  160.      
  161.     
  162.       1 
  163.      
  164.     
  165.       ′ 
  166.      
  167.     
  168.    
  169.      , 
  170.     
  171.    
  172.      … 
  173.     
  174.    
  175.      , 
  176.     
  177.     
  178.     
  179.       f 
  180.      
  181.      
  182.      
  183.        N 
  184.       
  185.      
  186.        ′ 
  187.       
  188.      
  189.     
  190.       ′ 
  191.      
  192.     
  193.    
  194.      ) 
  195.     
  196.    
  197.   
  198.     \mathcal P (Answer | \mathcal Q_0, f_1, \dots, f_N, f_1', \dots, f_{N'}') 
  199.    
  200.   
  201. P(Answer∣Q0​,f1​,…,fN​,f1′​,…,fN′′​) 。由于注释的答案不包含  
  202.  
  203.   
  204.    
  205.     
  206.     
  207.       f 
  208.      
  209.     
  210.       ∗ 
  211.      
  212.     
  213.       ′ 
  214.      
  215.     
  216.    
  217.   
  218.     f_*' 
  219.    
  220.   
  221. f∗′​的信息，模型学会忽略无关的事实，只关注重要的事实进行生成。
标签： 人工智能 NLP python
本文转载自: https://blog.csdn.net/qq_42730750/article/details/132060354
版权归原作者 夏小悠 所有， 如有侵权，请联系我们删除。
登录后发布评论

“WebCPM：首个开源的交互式网页搜索中文问答模型”的评论:

还没有评论
关于作者
...
overfit同步小助手
文章同步
相关阅读

网络安全法-网络运行安全

使用selenium/drissionpage时如何阻止chrome自动跳转http到https

docker desktop 里部署的Open WebUI 管理员密码忘记了的处理方法

在ubuntu20.04中搭建onsite比赛运行环境

利用开源的低代码表单设计器FcDesigner高效管理和渲染复杂表单结构

Kafka学习笔记

【前端】浏览器输入url到页面呈现发生了什么？