标签：boldsymbol right exp text Answering Question 答案 13.1 left
文章目录
介绍
对于 QA 任务，有两个输入：Question 问题和文章Source 来源，输出为根据所给文章可得到问题的 Answer 答案。如图1所示。
图 1 图1 图1
在此，Question 问题 有这样几种：
- 有标准答案的简单客观问题，如“谁是现任美国总统？”，答案就是特朗普，这样的问题与答案是不存在任何争议的。
- 多来源的问题，如“特朗普年龄比奥巴马大吗？”，这个答案就需要机器先在某篇文章中找到特朗普的年龄，再可能从其他文章中找出奥巴马的年龄，要通过不同来源才能得到答案。
- 没有标准答案的问题，如“约会时谁应该付钱，为什么？”，情感问题可能真的没有答案。
而有关答案的 Source 来源可以是很多种：如文章、网络、语音、视频等。
对于问题和来源都要经过一定的预处理，如通过BERT转成词向量嵌入等，且对于问题和来源得到的向量后可能还会通过Attention机制。接下来，通过一个寻找答案的模块输入预处理后的问题和来源，输出答案，而对于Answer 答案而言，有以下几种：
- word：词汇
- span in source：文中片段
- correct choice：选项
- paragraph：一整段话
以下，我们将通过各种答案的类型进行QA任务的学习，
如何回答答案
答案为词汇
图 2 图2 图2
• bAbI数据集1，
• MNIST of QA，QA任务中的MNIST
• 20 types of questions
• Synthesized这个数据集里面的QA都是合成的。
最简单的答案形式就是输出一个词汇，在QA领域，类似图像中的MNIST数据集一样，bAbI是最早最经典的QA数据集。它有20种不同的类别，具体数据可参见图2，像这样的QA其实已经是很简单的了，不过在2015年当年是被认为通过20个任务来测试机器的语言理解能力。当然，今天深度学习方法已经能达到95%以上的正确率了。那怎么做呢？ #pic_center
图
3
图3
图3
对于模型而言，简单来讲，这就是一个多分类问题，如图3所示，将所有可能的答案作为一个个类别,Answer模块就是一个多分类器。bAbI就是这么解的。当然，在此也可看出这其实并不是真正的理解语言，只是寻找模式规律而已。
答案为选项
图
4
图4
图4
另外一种类型的问题是选择题，在选择题中根据文章、问题来选择出正确的那个选项。对于模型而言，除了Source 来源、Question 问题的预处理外，还需要Choice 选项的预处理。接下来，这三个部分也可能互相都要使用Attention机制，再丢给最终寻找答案的模块。
此时，有两种解法，
- 第一种是将每一个选项一一与文章和问题进行判断，输出Yes/No，二分类问题。
- 第二种是直接把所有选项与文章和问题进行判断，输出正确的选项，这就又变成了一个多分类的问题。
- 但如果当成多分类的问题的话，可能会遇到这样的情况，不同问题有不同个数个选项，也就是说多分类时，类别数目会发生变化，这样很不容易处理，因此当成二分类问题是稳定、有弹性的解法。
答案为文中片段
图
5
图5
图5
第三种类型的答案是所给文章中的某一连续片段，如SQuAD2和DRCD。SQuAD就是从输入的文章里找其中一段，也就是基于抽取式的QA，这是英文中比较具有代表性的。对于中文，DRCD是比较著名的，仿照SQuAD。
解法如图5，输入Source 文章，模型要给文章中每个token一个作为起始的分数，和一个作为结尾的分数。接下来，选出其中起始分数最大的token和结尾分数最大的token，答案也就是从起始到结尾token间的这一段，如上图的 w 3 , w 4 , w 5 w_3,w_4,w_5 w3,w4,w5
那怎么产生起始和结尾的分数呢？
图 6 图6 图6
图5中，Source 同样是将其中每个token做词向量嵌入。而对于Question 则是产生两个向量，一个代表start，另一个代表end。然后，将Source 的每个词向量分别和这两个向量去算一下它们的某种相似度，可以是点乘，将这个相似度当作是起始和结束的分数即可。
图
7
图7
图7
图7中，如果是LSTM那么就是直接把黄色向量看做是一串sequence，然后丢LSTM得到结果。如果是BERT，就直接用黄色向量分别和start和end向量做点乘，分别得到开始和结束的score。
答案自由回答
图 8 图8 图8
最后一种也是最复杂的，答案是没有任何限制的，如图8。有代表性的数据集，对于英文来说有MS MARCO3，中文有DuReader。
在 MS MARCO 英文数据集中，问题有几种类型，答案就有几种类型。
- 第一种，答案在文章中找不到，但答案中的每个词汇是出现在文中各个部分的，所以像刚刚讲述Span 文中片段的解法便不再适用。
- 第二种，答案的词汇一部分出现在文章里，一部分出现在问题里。
- 第三种，答案的关键词出现在文章里。
- 第四种，答案没有出现在文章的任何地方，这种问题一般也是以Yes/No为答案。
Yes/No为答案可以先用一个问题分类器把答案是YES/NO的问题过滤出来，然后用前面提到的二分类的思想来解。
那对于这些不同类型的问题和答案，该怎么解呢？一个直觉的想法就是seq2seq，比较有代表性的便是S-net4。
S-net把这个任务当做抽取的任务来做，因为无论怎么样，答案都会有几个单词在文章中，MS MARCO在评估的时候是按匹配的单词数量来给分的。
S-net
S-net的方法包括论点抽取和答案合成两部分,如图9所示为流程。这两部分分两个阶段进行。论点提取部分的目的是抽取与问题相关的文章论点片段。答案合成部分的目的是根据抽取的论点片段生成答案。使用一个多任务学习框架用于论点提取，如图10所示，并使用序列到序列模型以及论点片段的起始和结束位置作为附加特征用于如图11所示的答案合成。
图
9
图9
图9
图
10
图10
图10
GRU
方程1描述了GRU的数学模型.
z
t
=
σ
(
W
h
z
h
t
−
1
+
W
x
z
x
t
+
b
z
)
r
t
=
σ
(
W
h
r
h
t
−
1
+
W
x
r
x
t
+
b
r
)
h
t
^
=
Φ
(
W
h
(
r
t
⊙
h
t
−
1
)
+
W
x
x
t
+
b
)
h
t
=
(
1
−
z
t
)
⊙
h
t
−
1
+
z
t
⊙
h
t
^
(1)
\begin{array}{l} z_{t}=\sigma\left(W_{h z} h_{t-1}+W_{x z} x_{t}+b_{z}\right) \\ r_{t}=\sigma\left(W_{h r} h_{t-1}+W_{x r} x_{t}+b_{r}\right) \\ \hat{h_{t}}=\Phi\left(W_{h}\left(r_{t} \odot h_{t-1}\right)+W_{x} x_{t}+b\right) \\ h_{t}=\left(1-z_{t}\right) \odot h_{t-1}+z_{t} \odot \hat{h_{t}} \end{array}\tag{1}
zt=σ(Whzht−1+Wxzxt+bz)rt=σ(Whrht−1+Wxrxt+br)ht^=Φ(Wh(rt⊙ht−1)+Wxxt+b)ht=(1−zt)⊙ht−1+zt⊙ht^(1)
- 论点提取
多任务学习框架论点提取。与SQuAD数据集不同的是，每个问题对应一个段落，而MS-MARCO数据集中每个问题都有几个相关段落。除了批注答案之外，MS-MARCO还批注哪一段是正确的。为此，提出了利用段落排名改进文本跨度预测的方法。
具体地说，如图10所示，除了预测文本跨度之外，还将利用篇章级的表征对段落排名作为一个额外的任务来改进多任务学习框架下的论点提取结果
- 论点片段预测
给定问题
Q
=
{
w
t
Q
}
t
=
1
m
\mathrm{Q}=\left\{w_{t}^{Q}\right\}_{t=1}^{m}
Q={wtQ}t=1m 和文章
P
=
{
w
t
P
}
t
=
1
n
\mathrm{P}=\left\{w_{t}^{P}\right\}_{t=1}^{n}
P={wtP}t=1n, 首先将单词转换为单词级嵌入和字符级嵌入。字符级嵌入是通过采用双向GRU的最终隐藏状态生成的。然后使用一个双向的GRU，分别对问题和文章中的所有单词产生融合序列信息新的表征
u
1
Q
，
…
,
u
m
Q
u_{1}^{Q}， \ldots, u_{m}^{Q}
u1Q，…,umQ和
u
1
P
，
…
,
u
n
P
u_{1}^{P}， \ldots, u_{n}^{P}
u1P，…,unP:
u
t
Q
=
BiGRU
Q
(
u
t
−
1
Q
,
[
e
t
Q
,
char
t
Q
]
)
u
t
P
=
BiGRU
P
(
u
t
−
1
P
,
[
e
t
P
,
char
t
P
]
)
(2)
\begin{aligned} u_{t}^{Q} &=\operatorname{BiGRU}_{Q}\left(u_{t-1}^{Q},\left[e_{t}^{Q}, \text { char }_{t}^{Q}\right]\right) \\ u_{t}^{P} &=\operatorname{BiGRU}_{P}\left(u_{t-1}^{P},\left[e_{t}^{P}, \operatorname{char}_{t}^{P}\right]\right) \end{aligned}\tag{2}
utQutP=BiGRUQ(ut−1Q,[etQ, char tQ])=BiGRUP(ut−1P,[etP,chartP])(2)
给出问题和文章表征
{
u
t
Q
}
t
=
1
m
\left\{u_{t}^{Q}\right\}_{t=1}^{m}
{utQ}t=1m，
{
u
t
P
}
t
=
1
n
\left\{u_{t}^{P}\right\}_{t=1}^{n}
{utP}t=1n, 通过对问题和文章中的单词进行软对齐来生成句子对表征
{
v
t
P
}
t
=
1
n
\left\{v_{t}^{P}\right\}_{t=1}^{n}
{vtP}t=1n，方法如下:
v
t
P
=
GRU
(
v
t
−
1
P
,
c
t
Q
)
(3)
v_{t}^{P}=\operatorname{GRU}\left(v_{t-1}^{P}, c_{t}^{Q}\right)\tag{3}
vtP=GRU(vt−1P,ctQ)(3)
其中 c t Q = att ( u Q , [ u t P , v t − 1 P ] ) c_{t}^{Q}=\operatorname{att}\left(u^{Q},\left[u_{t}^{P}, v_{t-1}^{P}\right]\right) ctQ=att(uQ,[utP,vt−1P]) 是文章对问题 ( u Q ) \left(u^{Q}\right) (uQ) 做注意力的上下文向量 :
s j t = v T tanh ( W u Q u j Q + W u P u t P ) a i t = exp ( s i t ) / Σ j = 1 m exp ( s j t ) c t Q = Σ i = 1 m a i t u i Q (4) \begin{aligned} s_{j}^{t} &=\mathrm{v}^{\mathrm{T}} \tanh \left(W_{u}^{Q} u_{j}^{Q}+W_{u}^{P} u_{t}^{P}\right) \\ a_{i}^{t} &=\exp \left(s_{i}^{t}\right) / \Sigma_{j=1}^{m} \exp \left(s_{j}^{t}\right) \\ c_{t}^{Q} &=\Sigma_{i=1}^{m} a_{i}^{t} u_{i}^{Q} \end{aligned}\tag{4} sjtaitctQ=vTtanh(WuQujQ+WuPutP)=exp(sit)/Σj=1mexp(sjt)=Σi=1maituiQ(4)
match-LSTM，将
u
j
P
u_{j}^{P}
ujP作为GRU的额外输入，在RNN的输入
(
[
u
t
P
,
c
t
Q
]
)
\left(\left[u_{t}^{P}, c_{t}^{Q}\right]\right)
([utP,ctQ])中添加gate来确定文章那部分部分的重要程度：
g
t
=
sigmoid
(
W
g
[
u
t
P
,
c
t
Q
]
)
[
u
t
P
,
c
t
Q
]
∗
=
g
t
⊙
[
u
t
P
,
c
t
Q
]
v
t
P
=
GRU
(
v
t
−
1
P
,
[
u
t
P
,
c
t
Q
]
∗
)
(5)
\begin{array}{l} g_{t}=\operatorname{sigmoid}\left(W_{g}\left[u_{t}^{P}, c_{t}^{Q}\right]\right) \\ {\left[u_{t}^{P}, c_{t}^{Q}\right]^{*}=g_{t} \odot\left[u_{t}^{P}, c_{t}^{Q}\right]} \\ v_{t}^{P}=\operatorname{GRU}\left(v_{t-1}^{P},\left[u_{t}^{P}, c_{t}^{Q}\right]^{*}\right) \end{array}\tag{5}
gt=sigmoid(Wg[utP,ctQ])[utP,ctQ]∗=gt⊙[utP,ctQ]vtP=GRU(vt−1P,[utP,ctQ]∗)(5)
使用
指
针
网
络
\large\color{#70f3ff}{\boxed{\color{green}{指针网络}}}
指针网络预测论点片段的位置。
将所有段落连接起来，为论点片段预测预测一个跨度。给出
{
v
t
P
}
t
=
1
N
\left\{v_{t}^{P}\right\}_{t=1}^{N}
{vtP}t=1N，其中
N
N
N为所有段落长度之和，利用注意机制为指针选择起始位置
(
p
1
)
\left(p^{1}\right)
(p1)和结束位置
(
p
2
)
\left(p^{2}\right)
(p2)，其表达式为:
s
j
t
=
v
T
tanh
(
W
h
P
v
j
P
+
W
h
a
h
t
−
1
a
)
a
i
t
=
exp
(
s
i
t
)
/
Σ
j
=
1
N
exp
(
s
j
t
)
p
t
=
argmax
(
a
1
t
,
…
,
a
N
t
)
(6)
\begin{array}{l} s_{j}^{t}=\mathrm{v}^{\mathrm{T}} \tanh \left(W_{h}^{P} v_{j}^{P}+W_{h}^{a} h_{t-1}^{a}\right) \\ a_{i}^{t}=\exp \left(s_{i}^{t}\right) / \Sigma_{j=1}^{N} \exp \left(s_{j}^{t}\right) \\ p^{t}=\operatorname{argmax}\left(a_{1}^{t}, \ldots, a_{N}^{t}\right) \end{array}\tag{6}
sjt=vTtanh(WhPvjP+Whaht−1a)ait=exp(sit)/Σj=1Nexp(sjt)pt=argmax(a1t,…,aNt)(6)
这里
h
t
−
1
a
h_{t-1}^{a}
ht−1a表示指针网络的最后一个隐藏状态。指针网络的输入是注意力上下文向量，由当前预测概率
a
t
a^{t}
at得出：
c
t
=
Σ
i
=
1
N
a
i
t
v
i
P
h
t
a
=
GRU
(
h
t
−
1
a
,
c
t
)
(7)
\begin{aligned} c_{t} &=\Sigma_{i=1}^{N} a_{i}^{t} v_{i}^{P} \\ h_{t}^{a} &=\operatorname{GRU}\left(h_{t-1}^{a}, c_{t}\right) \end{aligned}\tag{7}
cthta=Σi=1NaitviP=GRU(ht−1a,ct)(7)
在预测起始位置时，
h
t
−
1
a
h_{t-1}^{a}
ht−1a表示指针网络的初始隐藏状态。利用问题向量
r
Q
r^{Q}
rQ作为指针网络的初始状态。
r
Q
=
a
t
t
(
u
Q
,
v
r
Q
)
r^{Q}=a t t\left(u^{Q}, v_{r}^{Q}\right)
rQ=att(uQ,vrQ) 是问题的注意力上下文向量，其中
v
r
Q
v_{r}^{Q}
vrQ 是参数，计算：
s
j
=
v
T
tanh
(
W
u
Q
u
j
Q
+
W
v
Q
v
r
Q
)
a
i
=
exp
(
s
i
)
/
Σ
j
=
1
m
exp
(
s
j
)
r
Q
=
Σ
i
=
1
m
a
i
u
i
Q
(8)
\begin{aligned} s_{j} &=\mathrm{v}^{\mathrm{T}} \tanh \left(W_{u}^{Q} u_{j}^{Q}+W_{v}^{Q} v_{r}^{Q}\right) \\ a_{i} &=\exp \left(s_{i}\right) / \Sigma_{j=1}^{m} \exp \left(s_{j}\right) \\ r^{Q} &=\Sigma_{i=1}^{m} a_{i} u_{i}^{Q} \end{aligned}\tag{8}
sjairQ=vTtanh(WuQujQ+WvQvrQ)=exp(si)/Σj=1mexp(sj)=Σi=1maiuiQ(8)
对于这部分，目标函数是最小化以下交叉熵:
L
A
P
=
−
Σ
t
=
1
2
Σ
i
=
1
N
[
y
i
t
log
a
i
t
+
(
1
−
y
i
t
)
log
(
1
−
a
i
t
)
]
(9)
\mathcal{L}_{A P}=-\Sigma_{t=1}^{2} \Sigma_{i=1}^{N}\left[y_{i}^{t} \log a_{i}^{t}+\left(1-y_{i}^{t}\right) \log \left(1-a_{i}^{t}\right)\right]\tag{9}
LAP=−Σt=12Σi=1N[yitlogait+(1−yit)log(1−ait)](9)
其中
y
i
t
∈
{
0
,
1
}
y_{i}^{t} \in\{0,1\}
yit∈{0,1} 是标签.
y
i
t
=
1
y_{i}^{t}=1
yit=1 即
i
i
i是正确的位置，否则
y
i
t
=
0
y_{i}^{t}=0
yit=0.
- 排名
在这一部分中，将问题和每一篇文章从单词水平到篇章水平匹配起来。首先，使用问题表征
r
Q
r^Q
rQ对文章做注意力，得到文章表征
r
P
r^P
rP ,其中
r
P
=
a
t
t
(
u
P
,
v
r
P
)
r^{P}=a t t\left(u^{P}, v_{r}^{P}\right)
rP=att(uP,vrP) :
s
j
=
v
T
tanh
(
W
v
P
v
j
P
+
W
v
Q
r
Q
)
a
i
=
exp
(
s
i
)
/
Σ
j
=
1
n
exp
(
s
j
)
r
P
=
∑
i
=
1
n
a
i
v
i
P
(9)
\begin{array}{l} s_{j}=\mathrm{v}^{\mathrm{T}} \tanh \left(W_{v}^{P} v_{j}^{P}+W_{v}^{Q} r^{Q}\right) \\ a_{i}=\exp \left(s_{i}\right) / \Sigma_{j=1}^{n} \exp \left(s_{j}\right) \\ r^{P}=\sum_{i=1}^{n} a_{i} v_{i}^{P} \end{array}\tag{9}
sj=vTtanh(WvPvjP+WvQrQ)ai=exp(si)/Σj=1nexp(sj)rP=∑i=1naiviP(9)
接下来，将问题表征
r
Q
r^{Q}
rQ和篇章表征
r
P
r^{P}
rP合并，传递两个完全连接的层以获得匹配的分数，
g
=
v
g
T
(
tanh
(
W
g
[
r
Q
,
r
P
]
)
)
(10)
g=v_{g}^{\mathrm{T}}\left(\tanh \left(W_{g}\left[r^{Q}, r^{P}\right]\right)\right)\tag{10}
g=vgT(tanh(Wg[rQ,rP]))(10)
对于一个问题，每个候选篇章
P
i
P_{i}
Pi都有一个匹配的分数
g
i
g_{i}
gi。将他们的分数标椎化，并优化以下目标函数:
g
^
i
=
exp
(
g
i
)
/
Σ
j
=
1
k
exp
(
g
j
)
L
P
R
=
−
∑
i
=
1
k
[
y
i
log
g
^
i
+
(
1
−
y
i
)
log
(
1
−
g
^
i
)
]
(11)
\begin{array}{c} \hat{g}_{i}=\exp \left(g_{i}\right) / \Sigma_{j=1}^{k} \exp \left(g_{j}\right) \\ \mathcal{L}_{P R}=-\sum_{i=1}^{k}\left[y_{i} \log \hat{g}_{i}+\left(1-y_{i}\right) \log \left(1-\hat{g}_{i}\right)\right] \end{array}\tag{11}
g^i=exp(gi)/Σj=1kexp(gj)LPR=−∑i=1k[yilogg^i+(1−yi)log(1−g^i)](11)
其中
k
k
k是篇章的数量。示
y
i
∈
{
0
,
1
}
y_{i} \in\{0,1\}
yi∈{0,1}一个标签。
y
i
=
1
y_{i}=1
yi=1表示
P
i
P_{i}
Pi是正确的，否则
y
i
=
0
y_{i}=0
yi=0。
- 联合训练
通过最小化联合目标函数来训练明显提取部分:
L
E
=
r
L
A
P
+
(
1
−
r
)
L
P
R
(12)
\mathcal{L}_{E}=r \mathcal{L}_{A P}+(1-r) \mathcal{L}_{P R}\tag{12}
LE=rLAP+(1−r)LPR(12)
其中
r
r
r为两个损失函数权值的超参数。
- 回答合成
图
11
图11
图11
如图11所示，使用序列到序列的模型，以提取的论点为特征来综合答案。
首先对文章和问题中的所有单词进行编码， 给出
h
t
P
h_{t}^{P}
htP和
h
t
Q
h_{t}^{Q}
htQ的表征。在生成答案表征时，将基础词嵌入
e
t
p
e_{t}^{p}
etp与特征
f
t
s
f_{t}^{s}
fts和
f
t
e
f_{t}^{e}
fte组合在一起，分别表示答案提取模型预测的答案片段的起始位置和结束位置。$f_{t}^{s}=1
，
，
，f_{t}^{e}=1$ 分别表示该位置是答案跨度的起点和终点。
h
t
P
=
BiGRU
(
h
t
−
1
P
,
[
e
t
p
,
f
t
s
,
f
t
e
]
)
h
t
Q
=
BiGRU
(
h
t
−
1
Q
,
e
t
Q
)
(13)
\begin{aligned} h_{t}^{P} &=\operatorname{BiGRU}\left(h_{t-1}^{P},\left[e_{t}^{p}, f_{t}^{s}, f_{t}^{e}\right]\right) \\ h_{t}^{Q} &=\operatorname{BiGRU}\left(h_{t-1}^{Q}, e_{t}^{Q}\right) \end{aligned}\tag{13}
htPhtQ=BiGRU(ht−1P,[etp,fts,fte])=BiGRU(ht−1Q,etQ)(13)
在编码器的顶部，使用GRU与注意力作为解码器产生的答案。在每个解码时间步长
t
t
t时，GRU读取之前嵌入的
w
t
−
1
w_{t-1}
wt−1和之前的上下文向量
c
t
−
1
c_{t-1}
ct−1作为输入，计算新的隐藏状态
d
t
d_{t}
dt。为了初始化GRU隐藏状态，使用一个线性层，将最后一个后向编码器隐藏状态
h
←
1
P
\overleftarrow{h}_{1}^{P}
h
1P和
h
←
1
Q
\overleftarrow{h}_{1}^{Q}
h
1Q作为输入:
d
t
=
GRU
(
w
t
−
1
,
c
t
−
1
,
d
t
−
1
)
d
0
=
tanh
(
W
d
[
h
←
1
P
,
h
←
1
Q
]
+
b
)
(14)
\begin{array}{l} d_{t}=\operatorname{GRU}\left(w_{t-1}, c_{t-1}, d_{t-1}\right) \\ d_{0}=\tanh \left(W_{d}\left[\overleftarrow{h}_{1}^{P}, \overleftarrow{h}_{1}^{Q}\right]+b\right) \end{array}\tag{14}
dt=GRU(wt−1,ct−1,dt−1)d0=tanh(Wd[h
1P,h
1Q]+b)(14)
通过注意机制计算当前时间步长
t
t
t的上下文向量
c
t
c_{t}
ct，该机制将当前解码器状态
d
t
d_{t}
dt与每个编码器隐藏状态
h
t
h_{t}
ht匹配，得到加权表征。这里
h
i
h_{i}
hi由篇章表示
h
t
P
h_{t}^{P}
htP和问题表示
h
t
Q
h_{t}^{Q}
htQ组成。
s
j
t
=
v
a
T
tanh
(
W
a
d
t
−
1
+
U
a
h
j
)
a
i
t
=
exp
(
s
i
t
)
/
Σ
j
=
1
n
exp
(
s
j
t
)
c
t
=
Σ
i
=
1
n
a
i
t
h
i
(15)
\begin{aligned} s_{j}^{t} &=v_{a}^{\mathrm{T}} \tanh \left(W_{a} d_{t-1}+U_{a} h_{j}\right) \\ a_{i}^{t} &=\exp \left(s_{i}^{t}\right) / \Sigma_{j=1}^{n} \exp \left(s_{j}^{t}\right) \\ c_{t} &=\Sigma_{i=1}^{n} a_{i}^{t} h_{i} \end{aligned}\tag{15}
sjtaitct=vaTtanh(Wadt−1+Uahj)=exp(sit)/Σj=1nexp(sjt)=Σi=1naithi(15)
然后结合前面的词嵌入
w
t
−
1
w_{t-1}
wt−1,当前上下文向量
c
t
c_{t}
ct,和解码器状态
d
t
d_{t}
dt构造读出器状态
r
t
r_{t}
rt。然后，通过maxout隐藏层预测下一个单词与解码器词汇表上的softmax层。
r
t
=
W
r
w
t
−
1
+
U
r
c
t
+
V
r
d
t
m
t
=
[
max
{
r
t
,
2
j
−
1
,
r
t
,
2
j
}
]
T
p
(
y
t
∣
y
1
,
…
,
y
t
−
1
)
=
softmax
(
W
o
m
t
)
(16)
\begin{array}{c} r_{t}=W_{r} w_{t-1}+U_{r} c_{t}+V_{r} d_{t} \\ m_{t}=\left[\max \left\{r_{t, 2 j-1}, r_{t, 2 j}\right\}\right]^{\mathrm{T}} \\ p\left(y_{t} \mid y_{1}, \ldots, y_{t-1}\right)=\operatorname{softmax}\left(W_{o} m_{t}\right) \end{array}\tag{16}
rt=Wrwt−1+Urct+Vrdtmt=[max{rt,2j−1,rt,2j}]Tp(yt∣y1,…,yt−1)=softmax(Womt)(16)
读出器状态
r
t
r_{t}
rt 是一个
2
d
2d
2d 维向量 ，maxout层为
r
t
r_{t}
rt中的每两个数字取一个Max值，并生成一个d维向量
m
t
.
m_{t} .
mt.
目标是最大化输入语句的输出概率。因此，优化负对数似然损失函数:
L
S
=
−
1
∣
D
∣
Σ
(
X
,
Y
)
∈
D
log
p
(
Y
∣
X
)
(17)
\mathcal{L}_{S}=-\frac{1}{|\mathcal{D}|} \Sigma_{(X, Y) \in \mathcal{D}} \log p(Y \mid X)\tag{17}
LS=−∣D∣1Σ(X,Y)∈Dlogp(Y∣X)(17)
其中
D
\mathcal{D}
D是数据集。
X
X
X表示包含证据片段的问题和段落，
Y
Y
Y表示答案。
无答案
上述讲了好几种QA的形态，但还有一种特殊的状况需要我们考虑，因为并不是所有问题都有答案，如悖论。
对于那些不一定有答案的问题。
正确的做法应该是：不要回答，保持沉默。
所以该怎么让机器遇到不该回答的问题，选择不回答呢？有这样一个著名的数据集，SQuAD 2.0，就是测验机器不回答的能力，在这个数据集中有很多假的问题。举个例子，如问题是“1937年哪一个条约被签订”，而在文章中只提到了“1937年签订了一个条约，1940又签订了一个叫XXX的条约”，如果模型一般，便会拿取同一个句中的XXX条约名当作问题的答案，但其实这个问题的答案根本在文中没有出现。
那我们怎么让机器做到这件事情呢？
图
12
图12
图12
其实，在最原始的BERT5里就有试着解这个问题了，在文章里面加入一个特别的token “Null”,如图12。接下来就和抽取式QA一样，根据问题和文章给文中每一个token一个作为起始和终止的分数，如果最后“Null”起始的分数和终止的分数都是最大的，那么“Null”便是指这个问题没有答案。在BERT中[CLS]就是当作Null的token了。
但其实在实作中，还需要加很多条件。举例来说，我们在训练时很难得到Null作为起始和终止的分数都最高的状况，所以一般只要Null的起始和终止都超过某一个阈值分数就作为答案，这个阈值分数就作为超参数调节。
无答案的情况之前的工作主要集中在预测无答案的概率来判断是否有答案，然后他们并没有通过考虑判断答案的合理性性来判断答案是否存在，因此提出一种Read + Verify6的模型，如图13所示，它不仅能够利用阅读器从候选答案中进行抽取，并且产生无答案概率，而且利用一个答案验证器来决定预测的答案的合理性，检测这个答案和问题的匹配度。此外，引入两个新的loss函数来辅助reader模型能够更好的解决答案抽取过程中没有答案的情况。
当然，还有很多其他的做法，如SAN7 , 图15中，加一个分类模块，来决定这个问题能不能被回答，这个分类模块会通过文章和问题来判断问题能否被回答，二分类问题。
任务描述
给定一个上下文段落和问题, 机器不仅需要找到可回答问题的答案, 还必须检测出无法回答的情况。段落和问题被描述为单词字符的序列, 分别表示为 P = { x i p } i = 1 l p P=\left\{x_{i}^{p}\right\}_{i=1}^{l_{p}} P={xip}i=1lp 和 Q = { x j q } j = 1 l q Q=\left\{x_{j}^{q}\right\}_{j=1}^{l_{q}} Q={xjq}j=1lq, 其中 l p l_{p} lp 是段落长度, l q l_{q} lq 是问题长度。目标是预测答案 A A A, 该答案被约束为段落中的一段文本: A = { x i p } i = l a l b A=\left\{x_{i}^{p}\right\}_{i=l_{a}}^{l_{b}} A={xip}i=lalb, 或者如果没有答案则返回空字符串, 其中 l a l_{a} la 和 l b l_{b} lb 表示答案边界。
Read + Verify
图
13
图13
图13
如图13所示，系统由两个部分组成：
-
（1）无答案阅读器，用于提取候选答案并检测无法回答的问题；
-
（2）答案验证器，用于确定所提取的候选答案是否合法。
-
无答案阅读器
为了预测答案范围，当前方法首先将段落和问题嵌入并编码为两个固定大小的向量序列。
然后，利用各种注意力机制，例如双向注意力或再注意力，为段落和问题建立相互依赖的表征形式，分别为 U = { u i } i = 1 l p U=\left\{u_{i}\right\}_{i=1}^{l_{p}} U={ui}i=1lp , V = { v j } j = 1 l q V=\left\{v_{j}\right\}_{j=1}^{l_{q}} V={vj}j=1lq 。
最后，将问题表征形式概括为一个密集的向量
t
t
t，并利用指针网络在段落单词词上产生两个分数来表示答案边界：
o
j
=
w
v
T
v
j
,
t
=
∑
j
=
1
l
q
e
o
j
∑
k
=
1
l
q
e
o
k
v
j
α
,
β
=
pointer_nelwork
(
U
,
t
)
(18)
\begin{array}{c} o_{j}=w_{v}^{\mathrm{T}} v_{j}, t=\sum_{j=1}^{l_{q}} \frac{e^{o_{j}}}{\sum_{k=1}^{l_{q}} e^{o_{k}}} v_{j} \\ \alpha, \beta=\text { pointer\_nelwork }(U, t) \end{array}\tag{18}
oj=wvTvj,t=∑j=1lq∑k=1lqeokeojvjα,β= pointer_nelwork (U,t)(18)
其中
α
\alpha
α和
β
\beta
β是答案开始和结束边界的分数。
为了进一步检测问题是否无法回答，还加上无答案分数
z
z
z，然后使用共享的softmax函数对无答案分数和跨度分数进行归一化，得到一个联合的无答案目标，即：
L
j
o
i
n
t
=
−
log
(
(
1
−
δ
)
e
z
+
δ
e
α
a
β
b
e
z
+
∑
i
=
1
l
p
∑
j
=
1
l
p
e
α
i
β
j
)
(19)
\mathcal{L}_{j o i n t}=-\log \left(\frac{(1-\delta) e^{z}+\delta e^{\alpha_{a} \beta_{b}}}{e^{z}+\sum_{i=1}^{l_{p}} \sum_{j=1}^{l_{p}} e^{\alpha_{i} \beta_{j}}}\right)\tag{19}
Ljoint=−log(ez+∑i=1lp∑j=1lpeαiβj(1−δ)ez+δeαaβb)(19)
其中
a
a
a和
b
b
b是答案ground-truth起始位置和结束位置，如果问题是可回答的，则
δ
\delta
δ为1，否则为0。在测试时，一旦标准化的无答案分数超过某个阈值，就会检测到一个问题是无法回答的。
图
14
图14
图14
图14是答案验证器的概述。(a)运行三种不同模型的输入结构。(b) Transformer©token-wise交互模型，旨在比较两个句子，并聚合结果来验证答案。
- 带有辅助Loss的阅读器
虽然以往的无答案阅读器能够共同学习答案抽取和无答案检测，但每个单独任务都存在两个问题。
对于答案提取，以前的阅读器没有经过训练，不会为无答案问题寻找候选答案。然而，这里要求阅读器提取一个合理的答案，并将其提供给所有问题的下游验证阶段。
对于无答案检测，由于跨度分数和无答案分数之间的共享标准化，可能会引发冲突。由于这些标准化分数的总和总是1，过度高的跨度概率会导致低的无回答概率，反之亦然。因此，对答案跨度的置信度不准确，从而导致对无答案分数的预测不准确。
针对上述问题，提出了两个辅助损失，分别对每个任务进行优化和增强，互不干扰。
- 独立的跨度Loss
这种损失被设计用于答案提取。在此任务中，要求模型为所有可能的问题提取候选答案。因此，除了可回答的问题外，还将不可回答的案例作为正例，并将貌似合理的答案视为gold答案。为了不与无应答检测冲突，使用一个多头指针网络来额外产生另一对跨度分数
α
~
\tilde{\alpha}
α~ ，
β
~
\tilde{\beta}
β~ :
o
~
j
=
w
~
v
T
v
j
,
t
~
=
∑
j
=
1
l
q
e
o
ˉ
j
∑
k
=
1
l
q
e
o
ˉ
k
v
j
α
~
,
β
~
=
pointer_network
(
U
,
t
~
)
(20)
\begin{array}{c} \tilde{o}_{j}=\tilde{w}_{v}^{\mathrm{T}} v_{j}, \tilde{t}=\sum_{j=1}^{l_{q}} \frac{e^{\bar{o}_{j}}}{\sum_{k=1}^{l_{q}} e^{\bar{o}_{k}}} v_{j} \\ \tilde{\alpha}, \tilde{\beta}=\text { pointer\_network }(U, \tilde{t}) \end{array}\tag{20}
o~j=w~vTvj,t~=∑j=1lq∑k=1lqeoˉkeoˉjvjα~,β~= pointer_network (U,t~)(20)
其中多个头共享相同的网络架构，但具有不同的参数。然后，定义一个独立的跨度Loss为:
L
indep
−
I
=
−
log
(
e
α
ˉ
a
~
β
ˉ
b
~
∑
i
=
1
l
p
∑
j
=
1
l
p
e
α
ˉ
i
β
ˉ
j
)
(21)
\mathcal{L}_{\text {indep }-I}=-\log \left(\frac{e^{\bar{\alpha}_{\tilde{a}} \bar{\beta}_{\tilde{b}}}}{\sum_{i=1}^{l_{p}} \sum_{j=1}^{l_{p}} e^{\bar{\alpha}_{i} \bar{\beta}_{j}}}\right)\tag{21}
Lindep −I=−log(∑i=1lp∑j=1lpeαˉiβˉjeαˉa~βˉb~)(21)
其中
a
~
\tilde{a}
a~和
b
~
\tilde{b}
b~是增强的ground-truth答案边界。最终的跨度概率是通过在两对softmax归一化跨度分数上使用简单的平均池化获得的。
- 独立的无答案Loss
尽管使用了多头指针网络来防止冲突问题，但是无答案检测仍然可以被削弱，因为无答案分数
z
z
z是用span分数标准化的。因此，鼓励无答案检测的预测，这是通过引入一个独立的无答案损失来实现的:
L
indep-II
=
−
(
1
−
δ
)
log
σ
(
z
)
−
δ
log
(
1
−
σ
(
z
)
)
(22)
\mathcal{L}_{\text {indep-II }}=-(1-\delta) \log \sigma(z)-\delta \log (1-\sigma(z))\tag{22}
Lindep-II =−(1−δ)logσ(z)−δlog(1−σ(z))(22)
通过这个损失，期望模型在不考虑共享归一化操作的情况下对无答案分数
z
z
z产生一个更有信心的预测。最后，将上述损失合并如下:
L
=
L
j
o
i
n
t
+
γ
L
i
n
d
e
p
−
I
+
λ
L
indep
−
I
I
(23)
\mathcal{L}=\mathcal{L}_{j o i n t}+\gamma \mathcal{L}_{i n d e p-I}+\lambda \mathcal{L}_{\text {indep }-I I}\tag{23}
L=Ljoint+γLindep−I+λLindep −II(23)
- 答案验证器
提取答案后，利用答案验证器将答案句子与问题进行比较，从而识别支持答案的局部文本蕴涵。
在这里，将答案句定义为包含gold 答案或貌似合理答案的上下文句。探索三种不同的架构，如图14所示:(1)Model-I:将输入作为一个长序列的顺序模型，(2)**Model-II：**两个句子相互依赖地编码的交互模型，以及(3)**Model-III：**将两种方法都考虑在内的混合模型。
- (1)Model-I序列化体系结构
在模型- i中，我们将答案句子和问题以及提取的答案转换为一个有序的输入序列。然后，采用生成预训练转换器(GPT)来执行任务。
给定一个答案句子
S
S
S，一个问题
Q
Q
Q 和一个提取的答案
A
A
A, 将两个句子与答案连接起来，同时在两者之间添加定界符标记以获得$X=[S ; Q ; $ ; A] .$ 然后，对序列进行词嵌入和位置嵌入。多个Transformer块用于编码序列嵌入如下:
h
0
=
W
e
[
X
]
+
W
p
h
i
=
transformer_block
(
h
i
−
1
)
,
∀
i
∈
[
1
,
n
]
(24)
\begin{array}{c} h_{0}=W_{e}[X]+W_{p} \\ h_{i}=\text { transformer\_block }\left(h_{i-1}\right), \forall i \in[1, n] \end{array}\tag{24}
h0=We[X]+Wphi= transformer_block (hi−1),∀i∈[1,n](24)
其中
X
X
X 表示词汇中的序列索引 ,
W
e
W_e
We 是字符嵌入矩阵,
W
p
W_{p}
Wp 是位置嵌入矩阵,
n
n
n 是transformer块数。每个块由一个mask的多头self-attention层和一个前馈层组成。每一层之后使用残差连接和层标椎化。
最后一个token的激活
h
n
l
m
h_{n}^{l_{m}}
hnlm被输入一个线性投影层，然后输入一个softmax函数输出无答案概率
y
y
y:
p
(
y
∣
X
)
=
softmax
(
h
n
l
m
W
y
)
(25)
p(y \mid X)=\operatorname{softmax}\left(h_{n}^{l_{m}} W_{y}\right)\tag{25}
p(y∣X)=softmax(hnlmWy)(25)
使用一个标准的交叉熵目标来最小化负对数似然:
L
(
θ
)
=
−
∑
(
X
,
y
)
log
p
(
y
∣
X
)
(26)
\mathcal{L}(\theta)=-\sum_{(X, y)} \log p(y \mid X)\tag{26}
L(θ)=−(X,y)∑logp(y∣X)(26)
2. （2）Model-II：交互式体系结构
图14©所示，该体系结构旨在捕获两个句子之间的交互，以便识别它们的局部蕴含关系以验证答案。该模型包括以下几层：
Encoding: 使用GloVe词嵌入，还有字符嵌入。BiLSTM对字符进行编码，并连接最后两个隐藏状态以获得字符级嵌入。
此外，使用二进制特征来表明一个单词是否是答案的一部分。然后，所有嵌入和特征一起被一个权值共享的BiLSTM连接和编码，产生两组上下文表征
s
i
=
BiLSTM
(
[
word
i
s
;
char
i
s
;
fea
i
s
]
)
,
∀
i
∈
[
1
,
l
s
]
q
j
=
BiLSTM
(
[
word
j
q
;
char
j
q
;
fea
j
q
]
)
,
∀
j
∈
[
1
,
l
q
]
(26)
\begin{aligned} s_{i} &=\text { BiLSTM }\left(\left[\text { word }_{i}^{s} ; \text { char }_{i}^{s} ; \text { fea }_{i}^{s}\right]\right), \forall i \in\left[1, l_{s}\right] \\ q_{j} &=\operatorname{BiLSTM}\left(\left[\text { word }_{j}^{q} ; \operatorname{char}_{j}^{q} ; \text { fea }_{j}^{q}\right]\right), \forall j \in\left[1, l_{q}\right] \end{aligned}\tag{26}
siqj= BiLSTM ([ word is; char is; fea is]),∀i∈[1,ls]=BiLSTM([ word jq;charjq; fea jq]),∀j∈[1,lq](26)
其中
l
s
l_{s}
ls是回答句子的长度，
[
⋅
;
⋅
]
[\cdot ; \cdot]
[⋅;⋅] 表示连接。
推理建模:推理建模层用于捕获两个句子之间的交互，并产生两个感知推理的句子表征。首先计算所有元组
<
s
i
，
q
j
>
<s_{i}， q_{j}>
<si，qj>的点积作为注意权值，然后对这些权值进行归一化，得到注意力向量如下:
a
i
j
=
s
i
⊤
q
j
,
∀
i
∈
[
1
,
l
s
]
,
∀
j
∈
[
1
,
l
q
]
b
i
=
∑
j
=
1
l
q
e
a
i
j
∑
k
=
1
l
q
e
a
i
k
q
j
,
c
j
=
∑
i
=
1
l
s
e
a
i
j
∑
k
=
1
l
s
e
a
k
j
s
i
(27)
\begin{array}{c} a_{i j}=s_{i}^{\top} q_{j}, \forall i \in\left[1, l_{s}\right], \forall j \in\left[1, l_{q}\right] \\ b_{i}=\sum_{j=1}^{l_{q}} \frac{e^{a_{i j}}}{\sum_{k=1}^{l_{q}} e^{a_{i k}}} q_{j}, c_{j}=\sum_{i=1}^{l_{s}} \frac{e^{a_{i j}}}{\sum_{k=1}^{l_{s}} e^{a_{k j}}} s_{i} \end{array}\tag{27}
aij=si⊤qj,∀i∈[1,ls],∀j∈[1,lq]bi=∑j=1lq∑k=1lqeaikeaijqj,cj=∑i=1ls∑k=1lseakjeaijsi(27)
在这里，
b
i
b_{i}
bi是答案句
S
S
S中第
i
i
i 个单词的问题
Q
Q
Q中的注意力向量，
c
j
c_{j}
cj则是文章的注意力向量。
接下来，为了单独比较对齐对
{
(
s
i
,
b
i
)
}
i
=
1
l
s
\left\{\left(s_{i}, b_{i}\right)\right\}_{i=1}^{l_{s}}
{(si,bi)}i=1ls ，
{
(
q
j
,
c
j
)
}
j
=
1
l
q
\left\{\left(q_{j}, c_{j}\right)\right\}_{j=1}^{l_{q}}
{(qj,cj)}j=1lq 为了找到局部推理信息，使用权重共享的函数
F
F
F 对这些对齐对建模：
s
~
i
=
F
(
s
i
,
b
i
)
,
q
~
j
=
F
(
q
j
,
c
j
)
(28)
\tilde{s}_{i}=F\left(s_{i}, b_{i}\right), \tilde{q}_{j}=F\left(q_{j}, c_{j}\right)\tag{28}
s~i=F(si,bi),q~j=F(qj,cj)(28)
F
F
F 可以有各种形式，如BiLSTM、多层感知器等。这里使用了启发式函数
o
=
F
(
x
,
y
)
o=F(x, y)
o=F(x,y)，与其他选项相比表现出了良好的性能:
r
=
gelu
(
W
r
[
x
;
y
;
x
∘
y
;
x
−
y
]
)
g
=
σ
(
W
g
[
x
;
y
;
x
∘
y
;
x
−
y
]
)
o
=
g
∘
r
+
(
1
−
g
)
∘
x
(29)
\begin{array}{c} r=\operatorname{gelu}\left(W_{r}[x ; y ; x \circ y ; x-y]\right) \\ g=\sigma\left(W_{g}[x ; y ; x \circ y ; x-y]\right) \\ o=g \circ r+(1-g) \circ x \end{array}\tag{29}
r=gelu(Wr[x;y;x∘y;x−y])g=σ(Wg[x;y;x∘y;x−y])o=g∘r+(1−g)∘x(29)
其中gelu为高斯误差线性激活， o是逐元素乘法，省略偏差项。
句内建模：接下来，应用句子内建模层来捕获每个句子内的自相关性。
输入是感知推理的向量 s ~ i \tilde{s}_{i} s~i和 q ~ j \tilde{q}_{j} q~j，它们首先通过另一个BiLSTM层进行编码。然后在每个句子和它本身之间使用注意机制，如果 i = j i=j i=j，设置 a i j = − i n f a_{i j}=-i n f aij=−inf，以确保单词和它本身没有对齐。另一个函数 F F F分别用于产生具有自我意识的向量 s ^ i \hat{s}_{i} s^i和 q ^ j \hat{q}_{j} q^j。
**预测:**在最终预测之前，使用一个连接残差连接，用BiLSTM将句子建模为:
s
ˉ
i
=
BiLSTM
(
[
s
~
i
;
s
^
i
]
)
,
q
ˉ
j
=
BiLSTM
(
[
q
~
j
;
q
^
j
]
)
(30)
\bar{s}_{i}=\operatorname{BiLSTM}\left(\left[\tilde{s}_{i} ; \hat{s}_{i}\right]\right), \bar{q}_{j}=\operatorname{BiLSTM}\left(\left[\tilde{q}_{j} ; \hat{q}_{j}\right]\right)\tag{30}
sˉi=BiLSTM([s~i;s^i]),qˉj=BiLSTM([q~j;q^j])(30)
然后应用均值-最大池化操作对两句话的最终表示进行总结，即
s
ˉ
i
\bar{s}_{i}
sˉi和$\bar{q}_{j} $，然后将所有汇总后的向量连接到前馈分类器中，该前馈分类器由具有gelu激活的全连接层和softmax输出子层组成。产生无答案概率。如前所述，优化了负对数似然目标函数。
- （3）Model-III：混合体系结构
为了探究模型i和模型ii提取的特征如何被整合以获得更好的表达能力，研究了以上两个模型的组合，即模型iii。
将两个模型的输出向量合并为一个联合表示。然后采用统一的前馈分类器输出无应答概率。这样的设计允许我们测试性能是否能从两个不同架构的集成中受益。在实践中，我们使用一个简单的连接来合并两个信息源。
SAN
图
15
图15
图15
模型是SAN的变体,如图15所示。主要的区别是在模型中添加了额外的二元分类器来证明问题是无答案。粗略地说，该模型包括两个不同的层:共享层和特定于任务的层。
-
共享层几乎与SAN的较低层相同，它有一个词汇编码层、一个上下文层和一个记忆生成层。
-
在它之上，有针对不同任务的不同回答模块。跨度检测器采用SAN回答模块，二值分类器采用单层前馈神经网络。
-
词汇编码层
将 P P P和 Q Q Q的符号/表面特征映射到词embeddings .包含16-dim词性标注嵌入，8 -dim命名实体嵌入和4 -dim硬规则特。需要注意的是，使用较小的 P O S \mathrm{POS} POS 和NER嵌入来减少模型大小，它们主要服务于粗粒度词集群。此外，使用问题增强的段落词嵌入，可以看作是问题和段落之间的软匹配。最后，使用两个独立的两层位置前馈网络(FFN)将问题编码和段落编码映射到同一个维度。结果，获得了 Q Q Q的最终字典嵌入矩阵 E q ∈ R d × m E^{q} \in \mathbb{R}^{d \times m} Eq∈Rd×m， P P P 嵌入矩阵 E q ∈ R d × n E^{q} \in \mathbb{R}^{d \times n} Eq∈Rd×n
-
上下文编码层。
共享的两层BiLSTM被用于对段落和问题的上下文信息进行编码。为了避免过度拟合,使用 600维德国英语机器翻译训练数据集,与上述词汇映射进行最后的输入上下文编码层,以及第一个上下文编码的输出层作为其第二编码的输入层。因此，我们通过连接两个BiLSTM的输出来获得上下文编码层的最终表示: 问题： H q ∈ R 4 d × m H^{q} \in \mathbb{R}^{4 d \times m} Hq∈R4d×m ，文章： H p ∈ R 4 d × n H^{p} \in \mathbb{R}^{4 d \times n} Hp∈R4d×n
-
记忆产生层
在这一层中，通过融合文章 H p H^{p} Hp和问题 H q H^{q} Hq的信息来生成工作记忆。注意函数 f f f用于计算文章和问题之间的相似度得分矩阵 C C C，如下所示:
C = dropout ( f attention ( H ^ q , H ^ p ) ) ∈ R m × n C=\text { dropout }\left(f_{\text {attention }}\left(\hat{H}^{q}, \hat{H}^{p}\right)\right) \in \mathbb{R}^{m \times n} C= dropout (fattention (H^q,H^p))∈Rm×n
H ^ q \hat{H}^{q} H^q和 H ^ p \hat{H}^{p} H^p分别由 H q H^{q} Hq和 H p H^{p} Hp通过一层神经网络 R e L U ( W x ) R e L U(W x) ReLU(Wx)进行转换。一个问题感知的段落表示被计算为 U p = U^{p}= Up= concat ( H p , H q C ) \left(H^{p}, H^{q} C\right) (Hp,HqC)。之后对文章进行自我关注:U ^ p = U p drop diag ( f attention ( U p , U p ) ) \hat{U}^{p}=U^{p} \text { drop }_{\text {diag }}\left(f_{\text {attention }}\left(U^{p}, U^{p}\right)\right) U^p=Up drop diag (fattention (Up,Up))
其中 d r o p diag drop _{\text {diag }} dropdiag 意味着只删除相似矩阵上的对角线元素(即关注本身)。最后， U p U^{p} Up和 U ^ p \hat{U}^{p} U^p被连接起来，并通过BiLSTM传递，形成最终的结果memory: M = BiLSTM ( [ U p ] ; U ^ p ] ) \text { memory: } \left.M=\operatorname{BiLSTM}\left(\left[U^{p}\right] ; \hat{U}^{p}\right]\right) memory: M=BiLSTM([Up];U^p])
-
跨度检测器
跨度检测器采用多伦回答模块。形式上，在时间步长 t t t在 { 1 , 2 ， … , t − 1 } \{1,2，\ldots, t -1\} {1,2，…,t−1}范围内时，状态由 s t = s_{t}= st= GRU ( s t − 1 , x t ) \operatorname{GRU}\left(s_{t-1}, x_{t}\right) GRU(st−1,xt)得到，初始状态 s 0 s_{0} s0是 Q Q Q的总结:
s 0 = ∑ j α j H j q α j = exp ( w 0 ⋅ H j q ) ∑ j ′ exp ( w 0 ⋅ H j ′ q ) s_{0}=\sum_{j} \alpha_{j} H_{j}^{q}\\ \alpha_{j}=\frac{\exp \left(w_{0} \cdot H_{j}^{q}\right)}{\sum_{j^{\prime}} \exp \left(w_{0} \cdot H_{j^{\prime}}^{q}\right)} s0=j∑αjHjqαj=∑j′exp(w0⋅Hj′q)exp(w0⋅Hjq)
这里， x t x_{t} xt是从以前的状态 s t − 1 s_{t-1} st−1和记忆 M M M计算出来的
x t = ∑ j β j M j β j = softmax ( s t − 1 W 1 M ) . x_{t}=\sum_{j} \beta_{j} M_{j}\\ \beta_{j}=\operatorname{softmax}\left(s_{t-1} W_{1} M\right) . xt=j∑βjMjβj=softmax(st−1W1M).最后，利用双线性函数求出每个推理步骤 t ∈ { 0 , 1 , … , T − 1 } t \in\{0,1, \ldots, T-1\} t∈{0,1,…,T−1}的答案区间的开始点和结束点 :
P t begin = softmax ( s t W 2 M ) P t end = softmax ( s t W 3 M ) 4 \begin{array}{l} \qquad \begin{array}{r} P_{t}^{\text {begin }}=\operatorname{softmax}\left(s_{t} W_{2} M\right) \\ P_{t}^{\text {end }}=\operatorname{softmax}\left(s_{t} W_{3} M\right)^{4} \end{array} \end{array} Ptbegin =softmax(stW2M)Ptend =softmax(stW3M)4
最后的预测是每个时间步长的平均值:
P begin = 1 T ∑ t P t begin , P end = 1 T ∑ t P t end P^{\text {begin }}=\frac{1}{T} \sum_{t} P_{t}^{\text {begin }}, P^{\text {end }}=\frac{1}{T} \sum_{t} P_{t}^{\text {end }} Pbegin =T1t∑Ptbegin ,Pend =T1t∑Ptend
在训练过程中，在每个时间步水平上随机使用dropout. -
无回答的分类器
采用一层神经网络作为无法回答的二值分类器:
P u = sigmoid ( [ s 0 ; m 0 ] W 4 ) P^{u}=\operatorname{sigmoid}\left(\left[s_{0} ; m_{0}\right] W_{4}\right) Pu=sigmoid([s0;m0]W4)
其中 m 0 m_{0} m0是记忆的总结:
m 0 = ∑ j γ j M j γ j = exp ( w 5 ⋅ M j ) ∑ j ′ exp ( w 5 ⋅ M j ′ ) m_{0}=\sum_{j} \gamma_{j} M_{j}\\ \gamma_{j}=\frac{\exp \left(w_{5} \cdot M_{j}\right)}{\sum_{j^{\prime}} \exp \left(w_{5} \cdot M_{j^{\prime}}\right)} m0=j∑γjMjγj=∑j′exp(w5⋅Mj′)exp(w5⋅Mj)P u P^{u} Pu表示问题无回答的概率。联合模型的目标函数分为两部分:
L joint = L span + λ L classifier \mathcal{L}_{\text {joint }}=\mathcal{L}_{\text {span }}+\lambda \mathcal{L}_{\text {classifier }} Ljoint =Lspan +λLclassifier
跨度损失函数定义为:
L span = − ( log P begin + log P end ) \mathcal{L}_{\text {span }}=-\left(\log P^{\text {begin }}+\log P^{\text {end }}\right) Lspan =−(logPbegin +logPend )
定义二值分类器的目标函数:
L classifier = − { y ln P u + ( 1 − y ) ln ( 1 − P u ) } \mathcal{L}_{\text {classifier }}=-\left\{y \ln P^{u}+(1-y) \ln \left(1-P^{u}\right)\right\} Lclassifier =−{ylnPu+(1−y)ln(1−Pu)}
其中 y ∈ { 0 , 1 } y \in\{0,1\} y∈{0,1}
QA任务的资料
来源为文字资料
图
16
图16
图16
最常见的是根据一篇文章找出其中的答案，但是这个设置有些不切实际，看一篇文中找答案是比较简单的。所以真正使用QA的情况可能是这样的，如图16，我们有这样的问题Q，但我们不是从某一篇文章中找答案，而是从整个网络中找，因此整个网络资料都是我们的来源。
如在DrQA8中将维基百科当作来源，所以我们现需要一个搜寻的module 模块，找出有可能包含答案和问题比较相关的文章。然后根据这些相关的文章和问题来决定答案。在刚刚讲到的MS MARCO 和 DuReader数据集也是如此设置的，每一个问题都提供了数篇文章，要从这些文章找出正确答案。
DrQA
如图16所示，该DrQA根据给定的问题，使用TF-IDF算法（不可训练）对相关文档在知识库wikipedia中进行检索，随后训练一个LSTM（直接替换成BERT也是可以的）的阅读理解模型抽取答案。知识库widipedia可以直接换成其他文本知识库的。
如何训练？
1、文档检索的TF-IDF无法训练。
2、阅读理解模型使用LSTM模型，基于（问题Q，文档P，答案A）三元组进行训练，三元组来源一个是SQuAD标注的训练数据，一个是远程监督。所谓远程监督的意思是：根据问题Q使用TF-IDF找到相关文档P，只要相关文档P包含答案A，无论这个相关文档是什么文档，都可以构建出一个新的训练三元组（Q，P，A）。
-
阅读器
-
段落编码：
{ P 1 , … , P m } = LSTM ( { P ~ 1 , … , P ~ m } ) 0 P ~ i \left\{P_{1}, \ldots, P_{m}\right\}=\operatorname{LSTM}\left(\left\{\tilde{P}_{1}, \ldots, \tilde{P}_{m}\right\}\right)_{0} \quad \tilde{P}_{i} {P1,…,Pm}=LSTM({P~1,…,P~m})0P~i 包含单词 p i p_{i} pi 上下文的信息。
特征向量 P ~ i \tilde{P}_{i} P~i 有以下部分组成:
Word Embedding: f e m b ( p i ) = E ( p i ) f_{e m b}\left(p_{i}\right)=\mathbf{E}\left(p_{i}\right) femb(pi)=E(pi)
精确匹配: 采用了三个简单的二进制特征，表示 p i p_{i} pi 是否可以 与q中的一个疑问词精确匹配。
词特征: f token ( p i ) = ( POS ( p i ) , N E R ( p i ) , T F ( p i ) ) f_{\text {token }}\left(p_{i}\right)=\left(\operatorname{POS}\left(p_{i}\right), N E R\left(p_{i}\right), T F\left(p_{i}\right)\right) ftoken (pi)=(POS(pi),NER(pi),TF(pi)),添加了一些手工特性, 这些特性 反映了 p i p_{i} pi 在其上下文的一些属性, 包括它的词性(POS),实体命名识别(NER)标记以及标准化词频 ( T F ) (\mathrm{TF})_{} (TF) 。
问题注意力向量: f align ( p i ) = ∑ j a i , j E ( q j ) f_{\text {align }}\left(p_{i}\right)=\sum_{j} a_{i, j} E\left(q_{j}\right) falign (pi)=∑jai,jE(qj),其中注意力得分 a i , j a_{i, j} ai,j 表示 p i p_{i} pi 和每个问题单词 q j q_{j} qj 之间的相似性。其中 a i , j a_{i, j} ai,j 可以由词嵌入的非线性映射之间的点积计算得到
a i , j = exp ( α ( E ( p i ) ) ⋅ α ( E ( q j ) ) ) ∑ j ′ exp ( α ( E ( p i ) ) ⋅ α ( E ( q j ′ ) ) ) a_{i, j}=\frac{\exp \left(\alpha\left(\mathbf{E}\left(p_{i}\right)\right) \cdot \alpha\left(\mathbf{E}\left(q_{j}\right)\right)\right)}{\sum_{j^{\prime}} \exp \left(\alpha\left(\mathbf{E}\left(p_{i}\right)\right) \cdot \alpha\left(\mathbf{E}\left(q_{j^{\prime}}\right)\right)\right)} ai,j=∑j′exp(α(E(pi))⋅α(E(qj′)))exp(α(E(pi))⋅α(E(qj)))
α ( ⋅ ) \alpha(\cdot) α(⋅) 是一个非线性relu。 -
问题编码
在 q i q_{i} qi 的词嵌入应用另一个递归神经网络，并将产生的隐藏单元合并成另一个向量: { q 1 , … , q l } → q . \left\{\mathbf{q}_{1}, \ldots, \mathbf{q}_{l}\right\} \rightarrow \mathbf{q} . {q1,…,ql}→q.
q = ∑ j b j q j \mathbf{q}=\sum_{j} b_{j} \mathbf{q}_{j} q=∑jbjqj ， b j b_{j} bj 表示每个问题单词的重要程度：
b j = exp ( w ⋅ q j ) ∑ j ′ exp ( w ⋅ q j ′ ) b_{j}=\frac{\exp \left(\mathbf{w} \cdot \mathbf{q}_{j}\right)}{\sum_{j^{\prime}} \exp \left(\mathbf{w} \cdot \mathbf{q}_{j^{\prime}}\right)} bj=∑j′exp(w⋅qj′)exp(w⋅qj) -
预测
取段落向量 { p 1 , … , p m } \left\{\mathbf{p}_{1}, \ldots, \mathbf{p}_{m}\right\} {p1,…,pm} 和问题向量 q \mathbf{q} q 作为输入，并简单地训练两个分类器作为预测跨度位置。计算每个token 开始和结束的概率为：
P start ( i ) ∝ exp ( p i W s q ) P end ( i ) ∝ exp ( p i W e q ) \begin{aligned} P_{\text {start }}(i) & \propto \exp \left(\mathbf{p}_{i} \mathbf{W}_{s} \mathbf{q}\right) \\ P_{\text {end }}(i) & \propto \exp \left(\mathbf{p}_{i} \mathbf{W}_{e} \mathbf{q}\right) \end{aligned} Pstart (i)Pend (i)∝exp(piWsq)∝exp(piWeq)
那这些相关文章从哪里来呢？用一个搜索引擎搜索问题，将前十篇文章拿出来作为相关文章即可。但这样也会遇到一个问题，搜索引擎搜到的文章不是都有正确答案的，所以对QA模型要先判断能否从现在的文章中得到正确答案，而怎么滤掉哪些不相关的文章也是一个值得研究的问题。
V-Net
V-Net8根据输入的问题和多篇文章得到多个答案 A 1 , A 2 , . . . , A n A_1,A_2,...,A_n A1,A2,...,An ，而选择哪一个作为最终答案，在V-Net中的方法是投票的方式，如十篇文章中八篇都得到了一样的答案，那么这个答案就作为我们的最终答案输出。
（这个场景正对应我们平常在搜索引擎中的搜索。当键入我们想要找的内容，会命中很多内容，而通常其中只有一项是我们真正需要的，因此我们会多个答案对比，从而找到最终想要的。）
图 17 图17 图17
图17中模型包含三个部分：答案提取模块，答案内容评分模块，与答案交叉验证模块
首先分别在每篇文章中提取回答，即确定候选回答在文章中的位置；其次， 用打分函数对每个答案进行打分，即对每个候选回答的内容进行评价，最后，再对比每个回答，让每个回答相互验证。这三步会共同决定最终的答案。
-
答案提取模块
编码：将所有单词向量化 (主要是字符向量和与词向量拼接), 然后, 用biLSTM编码问题与文章集:
u t Q = B i LSTM Q ( u t − 1 Q , [ e t Q , c t Q ] ) u t P i = B i LSTM P ( u t − 1 P i , [ e t P i , c t P i ] ) \begin{aligned} u_{t}^{Q} &=B i \operatorname{LSTM}_{Q}\left(u_{t-1}^{Q},\left[e_{t}^{Q}, c_{t}^{Q}\right]\right) \\ u_{t}^{P_{i}} &=B i \operatorname{LSTM}_{P}\left(u_{t-1}^{P_{i}},\left[e_{t}^{P_{i}}, c_{t}^{P_{i}}\right]\right) \end{aligned} utQutPi=BiLSTMQ(ut−1Q,[etQ,ctQ])=BiLSTMP(ut−1Pi,[etPi,ctPi])
其中 e t , c t e_{t}, c_{t} et,ct 分别是第 t个词的词向量与字符向量, 可以看出, 每篇文章是单独训练的。Q-P Matching: 将Q 与P 进行注意力得分计算, 这里使用的是attention flow layer产生一个混淆矩阵:
S t , k = u t Q T ⋅ u k P i S_{t, k}=u_{t}^{Q^{T}} \cdot u_{k}^{P_{i}} St,k=utQT⋅ukPi
接下来得到 p2q attention:
a t = softmax ( S t : ) U ~ : t P i = ∑ j a t j ⋅ U : j P i \begin{array}{l} a_{t}=\operatorname{softmax}\left(S_{t:}\right) \\ \tilde{U}_{: t}^{P_{i}}=\sum_{j} a_{t j} \cdot U_{: j}^{P_{i}} \end{array} at=softmax(St:)U~:tPi=∑jatj⋅U:jPi
然后, 再经过一 biLSTM得到新的内部表征:
v t P i = B i LSTM M ( v t − 1 P i , u ~ t P i ) v_{t}^{P_{i}}=B i \operatorname{LSTM}_{M}\left(v_{t-1}^{P_{i}}, \tilde{u}_{t}^{P_{i}}\right) vtPi=BiLSTMM(vt−1Pi,u~tPi)答案边界预测:
有了上述的内部表征，第一个模块终于可以给出答案在文章中位置的预测了:
g k t = w 1 a T tanh ( W 2 a [ v k P , h t − 1 a ] ) α k t = exp ( g k t ) / ∑ j = 1 ∣ P ∣ exp ( g j t ) c t = ∑ k = 1 ∣ P ∣ a k t ⋅ v k P h t a = LSTM ( h t − 1 a , c t ) \begin{array}{c} g_{k}^{t}=w_{1}^{a T} \tanh \left(W_{2}^{a}\left[v_{k}^{P}, h_{t-1}^{a}\right]\right) \\ \alpha_{k}^{t}=\exp \left(g_{k}^{t}\right) / \sum_{j=1}^{|P|} \exp \left(g_{j}^{t}\right) \\ c_{t}=\sum_{k=1}^{|P|} a_{k}^{t} \cdot v_{k}^{P} \\ h_{t}^{a}=\operatorname{LSTM}\left(h_{t-1}^{a}, c_{t}\right) \end{array} gkt=w1aTtanh(W2a[vkP,ht−1a])αkt=exp(gkt)/∑j=1∣P∣exp(gjt)ct=∑k=1∣P∣akt⋅vkPhta=LSTM(ht−1a,ct)
则第一部分的loss:
L boundary = − 1 N ∑ i = 1 N ( log α y i 1 1 + log α y i 2 2 ) L_{\text {boundary }}=-\frac{1}{N} \sum_{i=1}^{N}\left(\log \alpha_{y_{i}^{1}}^{1}+\log \alpha_{y_{i}^{2}}^{2}\right) Lboundary =−N1i=1∑N(logαyi11+logαyi22)
其中 y i 1 , y i 2 y_i^1,y_i^2 yi1,yi2为第偏文章的起点与终点。 -
答案内容评分模块
此模块对上一模块得到的候选答案进行评分, 对每个候选答案的每个词判断其是否在应该出现在答案中:
p k c = sigmoid ( w 1 c R e L U ( W 2 2 v k P i ) ) p_{k}^{c}=\operatorname{sigmoid}\left(w_{1}^{c} R e L U\left(W_{2}^{2} v_{k}^{P_{i}}\right)\right) pkc=sigmoid(w1cReLU(W22vkPi))
此为第k个词出现在答案中的概率。将边界标签转换成一个连续的分段，这意味着在答案跨度内的单词将被标记为1，其他单词将被标记为0。损失函数为平均交叉熵:
L content = − 1 N 1 ∣ P ∣ ∑ i = 1 N ∑ j = 1 ∣ P ∣ [ y k c log p k c + ( 1 − y k c ) log ( 1 − p k c ) ] L_{\text {content }}=-\frac{1}{N} \frac{1}{|P|} \sum_{i=1}^{N} \sum_{j=1}^{|P|}\left[y_{k}^{c} \log p_{k}^{c}+\left(1-y_{k}^{c}\right) \log \left(1-p_{k}^{c}\right)\right] Lcontent =−N1∣P∣1i=1∑Nj=1∑∣P∣[ykclogpkc+(1−ykc)log(1−pkc)] -
答案交叉验证模块
这一模块对所有候选答案进行attention,从而找到最佳答累.
有了答案概率，可以把文章 i i i的答案表示为这篇文章中所有单词的加权和:
r A i = 1 ∣ P i ∣ ∑ k = 1 ∣ P i ∣ p k c [ e k P i , c k P i ] r^{A_{i}}=\frac{1}{\left|P_{i}\right|} \sum_{k=1}^{\left|P_{i}\right|} p_{k}^{c}\left[e_{k}^{P_{i}}, c_{k}^{P_{i}}\right] rAi=∣Pi∣1k=1∑∣Pi∣pkc[ekPi,ckPi]
应用attention:
s i , j = { 0 , if i = j r A i T ⋅ r A j , otherwise , α i , j = exp ( s i , j ) / ∑ k = 1 n exp ( s i , k ) r ~ A i = ∑ j = 1 n α i , j A j \begin{array}{c} s_{i, j}=\left\{\begin{array}{l} 0, \quad \text { if } i=j \\ r^{A_{i}^{T}} \cdot r^{A_{j}}, \quad \text { otherwise }, \end{array}\right. \\ \alpha_{i, j}=\exp \left(s_{i, j}\right) / \sum_{k=1}^{n} \exp \left(s_{i, k}\right) \\ \tilde{r}^{A_{i}}=\sum_{j=1}^{n} \alpha_{i, j}^{A_{j}} \\ \end{array} si,j={0, if i=jrAiT⋅rAj, otherwise ,αi,j=exp(si,j)/∑k=1nexp(si,k)r~Ai=∑j=1nαi,jAj
这里 r ~ A i \tilde{\mathbf{r}}^{A_{i}} r~Ai是根据注意权重从其他段落收集到的验证信息。然后把它和原始的表示 r A i \mathbf{r}^{A_{i}} rAi一起传递到一个完全连接的层:
g i v = w v ⊤ [ r A i , r ~ A i , r A i ⊙ r ~ A i ] g_{i}^{v}=\mathbf{w}^{v \top}\left[\mathbf{r}^{A_{i}}, \tilde{\mathbf{r}}^{A_{i}}, \mathbf{r}^{A_{i}} \odot \tilde{\mathbf{r}}^{A_{i}}\right] giv=wv⊤[rAi,r~Ai,rAi⊙r~Ai]
进一步归一化所有段落的这些分数，以获得候选答案 A i A_{i} Ai的验证分数:
p i v = exp ( g i v ) / ∑ j = 1 n exp ( g j v ) p_{i}^{v}=\exp \left(g_{i}^{v}\right) / \sum_{j=1}^{n} \exp \left(g_{j}^{v}\right) piv=exp(giv)/j=1∑nexp(gjv)
为了训练这个验证模型，将 gold 篇章中的答案作为gold答案。而损失函数可以表示为正确答案的负对数概率:
L verify = − 1 N ∑ i = 1 N log p y i v v L_{\text {verify }}=-\frac{1}{N} \sum_{i=1}^{N} \log p_{y_{i}^{v}}^{v} Lverify =−N1i=1∑Nlogpyivv其中 y i v y_{i}^{v} yiv是第 i i^{ } i实例的候选答案中所有正确答案的索引
-
联合训练
L = L boundary + β 1 L content + β 2 L verify \mathcal{L}=\mathcal{L}_{\text {boundary }}+\beta_{1} \mathcal{L}_{\text {content }}+\beta_{2} \mathcal{L}_{\text {verify }} L=Lboundary +β1Lcontent +β2Lverify
来源为图片
除了文字，还有其他可能的类型当作来源，如上图的图片作为来源。而比较常见的解法就是把一张图片丢到CNN里面，CNN就会给图片的每一小块一个向量表示，所以一张图片也是表示成一堆向量。类似于一篇文章输给BERT后得到的就是一堆embedding词向量的序列。接下来用到QA的方法和文字一样。
来源为语音
其实声音也包含了十分丰富的资讯，那怎么做语音的QA呢？最简单的方法是先做语音辨识，把声音讯号转成对应文字，然后通过文字版QA解决。
在出现文字版SQuAD后，老师的实验室便创造了语音版的SQuAD，把文字版的SQuAD念一遍。
https://github.com/chiahsuan156/ODSQA
那在解决语音QA时，通常会用到语音辨识，但语音辨识的结果可能并不准确。因此有这样的研究，如图20，也许对于语音QA，并不需要读文字，而是使用 Subword Units 子词单位 ，比如说以中文为例，“chengshi”的发音可能被辨识为“城市或程式”，如果以字为单位，那这两种结果是完全不一样的。但是如果以重音符号为分割，将整段声音经此拆分为多个子词单位，这样语音QA效果更好。
在Spoken SQuAD任务9中，在测试过程中，这些模型以一个机器转录的语音文档和一个问题作为输入，输出是从ASR转录中提取的文本跨度。我们首先在SQuAD训练集上训练这些模型，并比较口语SQuAD测试集的测试结果。此外，模型可以在文本文档或语音文档的ASR转录上进行训练。
SQA系统由ASR模块和阅读理解模块组成。在这一节中，我们首先简要介绍我们使用的阅读理解模型。然后介绍了如何利用子词序列嵌入来减轻ASR错误的影响。
阅读理解模式
• BiDirectional Attention Flow (BiDAF)
• R-NET
• Mnemonic Reader
• FusionNet
• Dr.QA
具体内容可看
Subword单位
图
20
图20
图20
ASR错误是不可避免的。然而，当一个转录词是错误的，这个词的一些子词单位可能仍然正确转录。因此，如图20所示，利用子词单位增强词嵌入可以减轻语音识别错误的影响。
这里使用了单词的音素序列。我们采用CNN从单词的音素序列中生成嵌入，这个网络称为phoneme -CNN。
如图20所示,通过一个卷积核获得一个单词的特征。假设一个单词 W W W由一个音素序列 P = [ p 1 ， … , p l ] P=\left[p_{1}， \ldots, p_{l}\right] P=[p1，…,pl]组成，其中 l l l为该单词的音素数。
设 H ∈ R C × d H \in \mathbb{R}^{C \times d} H∈RC×d为查找音素嵌入矩阵表，其中 C C C为音素的个数， d d d为音素嵌入的维数。换句话说，每个音素对应于一个 d d d 维向量。通过查表，将形成音素嵌入矩阵 E ∈ R l × d E \in \mathbb{R}^{l \times d} E∈Rl×d。
E E E与 卷积核F之间的卷积以步长1得到了一维向量 Z ∈ R l − k + 1 Z \in \mathbb{R}^{l-k+1} Z∈Rl−k+1。在最大池化 Z Z Z之后，我们得到一个标量值。由于我们连接了来自不同卷积核的所有输出标量，卷积核的数量决定了嵌入的音素序列的大小。
卷积核本质上是扫描音素 n \mathrm{n} n -gram,其中n-gram的大小是卷积核的高度(以上 k k k的数目)。使用阅读理解模型对滤波器的所有参数和音素嵌入矩阵 H H H进行端到端的学习。也可以合并其他子词单位，如音节，由上述相同的CNN架构。我们将用单词的音节序列做实验。
spoken QA
在这个任务中，当给模型一篇口语文章时，它需要找到一个文本形式问题的答案。SQA可以通过ASR模块和阅读理解模块的串联来解决。语音SQuAD的流程图如图21所示。使用语音文档的ASR转录，阅读理解模块可以根据问题返回文本答案。
最直观的评估文本答案的方法是直接计算预测文本答案和ground-truth文本答案之间的精确匹配(EM)和F1分数。
如果预测文本答案和ground-truth文本答案完全相同，则EM得分为1，否则为0。F1分数是基于精度和召回率。Precision是ground-truth答案中存在于预测答案中的单词的百分比，recall是ground-truth答案中也出现在预测答案中的单词的百分比.
图
21
图21
图21
上述对文本答案的评价不仅考虑了阅读理解系统的表现，也考虑了ASR系统的表现。如果阅读理解系统正确地识别出了与答案对应的转录中的单词序列，但是答案中的单词被错误识别，那么这个答案就会被认为是完全错误的。
这是非常可能的，因为大多数答案都是名字实体，通常不在词汇表中。因此，我们提出了专为SQA设计的第二种评估方法。在第二种方法中，不返回文本答案 ,机器返回与答案对应的跨度。
换句话说，它输出从语音文档中提取的音频片段作为答案。请根据答题卡中的正确答案的时间跨度给出答案。因为在SQuAD中文档中总是存在一个正确的答案，所以我们可以强制对齐语音文档及其参考转录，以获得正确答案跨度。我们计算系统输出的时间跨度和ground-truth时间跨度之间的音频重叠评分(AOS)，如下式所示。
A
O
S
=
X
∩
Y
X
∪
Y
A O S=\frac{X \cap Y}{X \cup Y}
AOS=X∪YX∩Y
其中
X
X
X 为预测答案的音频时间间隔，
Y
Y
Y为ground-truth答案的音频时间间隔。AOS对重叠的部分进行奖励，对预测过长的时间跨度的模型进行惩罚。
第二种评价方法是必要的。在听力测试中，即使对人类来说，要正确地抄写口语中的每一个单词也是极其困难的。
然而，如果一个人正确理解了整个语音文件，他/她可以很容易地选择正确的片段对应的答案在音频文件。因此，我们认为第二种方法更好地评价了SQA系统的推理能力。
领域自适应对抗学习
领域自适应10:包含源域和目标域，目的是使得目标域通过源域的辅助学习到更好的特征。
这里目标域是ASR转录的文本，源域是文字QA。
对于文字QA是没有语音辨识的错误问题的，因此我们期待可以通过对抗学习的方法用文字QA来辅助 ASR转录语音QA的训练。
图
22
图22
图22
这里我们选择QANet作为基础模型，原因如下:1)QANet在SQuAD上的性能好，2)由于QANet中完全没有循环网络，在SQuAD上达到相同性能时，其训练速度比BiDAF快5倍。
网络体系结构如图22所示。左边的块和右边的块组成两个QANet，每个QANet都以一个文档和一个问题作为输入，并输出一个答案。在QANet中，首先，嵌入编码器获取q或d中每个单词的单词和字符的嵌入，然后建模单词之间的时间交互，并将单词向量提炼为上下文化的单词表征。QANet中使用的所有编码器块都完全由深度可分离的卷积和自我关注组成。这里的直觉是，卷积组件可以建模局部交互，而自注意组件专注于建模全局交互。上下文查询关注层生成问题-文档相似度矩阵，并计算上下文词的问题感知向量表示。在此之后，一个包含七个编码器块的模型编码器层捕获基于问题的上下文单词之间的交互。最后，输出层预测文档中的起始位置和结束位置，以从文档中提取答案跨度。
本文的重点是将领域自适应应用于SQA。在这种方法中，我们有两个SQA模型(QANets)，一个来自目标域数据(ASR转录 )，另一个来自源域数据(文本)。因为这两个域共享公共信息，所以可以绑定这两个模型中的一些层，以便对共享的特性建模。因此，我们可以选择是否应该共享QA模型中的每一层。绑定源层和目标层之间的权重以学习对称映射是将源域和目标域数据投影到共享的公共空间。
更具体地说，我们在图22所示的SQA模型中加入了一个领域鉴别器，它可以强制嵌入编码器将源域和目标域的句子投射到共享的公共空间中，从而使得ASR具有改正错误。尽管这两个域的嵌入编码器都可以隐式学习一些常见的潜在表征，但对抗学习可以提供一个更直接的训练信号来对齐这两个域的嵌入编码器的输出分布。嵌入编码器接收一个字向量序列，并生成一个相同长度的隐藏向量序列。
Ψ tar ( q ) \Psi_{\text {tar }}(q) Ψtar (q) 和 Ψ tar ( d ) \Psi_{\text {tar }}(d) Ψtar (d) ( Ψ src ( q ) \left(\Psi_{\text {src }}(q)\right. (Ψsrc (q) ， Ψ src ( d ) ) \left.\Psi_{\text {src }}(d)\right) Ψsrc (d)) 分别表示目标(源)域中给定的问题 q q q和文档 d d d的隐藏向量序列。
域鉴别器
D
D
D的重点是识别域的向量序列是来自
Ψ
t
a
r
\Psi_{\mathrm{tar}}
Ψtar 或者
Ψ
s
r
c
\Psi_{\mathrm{src}}
Ψsrc，目标是最小化
L
dis
L_{\text {dis }}
Ldis .
L
d
i
s
=
E
(
q
,
d
,
a
)
∼
tar
[
log
D
(
Ψ
t
a
r
(
q
)
)
+
log
D
(
Ψ
t
a
r
(
d
)
)
]
+
E
(
q
,
d
,
a
)
∼
src
[
log
(
1
−
D
(
Ψ
s
r
c
(
q
)
)
+
log
(
1
−
D
(
Ψ
s
r
c
(
d
)
)
]
\begin{aligned} L_{\mathrm{dis}} =E_{(q, d, a) \sim \operatorname{tar}}\left[\log D\left(\Psi_{\mathrm{tar}}(q)\right)+\log D\left(\Psi_{\mathrm{tar}}(d)\right)\right] \\ +E_{(q, d, a) \sim \operatorname{src}}\left[\operatorname { l o g } \left(1-D\left(\Psi_{\mathrm{src}}(q)\right)+\log \left(1-D\left(\Psi_{\mathrm{src}}(d)\right)\right]\right.\right. \end{aligned}
Ldis=E(q,d,a)∼tar[logD(Ψtar(q))+logD(Ψtar(d))]+E(q,d,a)∼src[log(1−D(Ψsrc(q))+log(1−D(Ψsrc(d))]
即一个来自目标域的训练集：
(
(
q
,
d
,
a
)
∼
((q, d, a) \sim
((q,d,a)∼ tar),
D
D
D学习给
q
q
q和
d
d
d分配一个较低的分数，也就是最小化
D
(
Ψ
tar
(
q
)
)
D\left(\Psi_{\operatorname{tar}}(q)\right)
D(Ψtar(q)) 和
D
(
Ψ
t
a
r
(
d
)
)
.
D\left(\Psi_{\mathrm{tar}}(d)\right) .
D(Ψtar(d)).
一个来自源域的训练集： ( ( q , d , a ) ∼ s r c ) , D ((q, d, a) \sim \mathrm{src}), D ((q,d,a)∼src),D学习给 q q q和 d d d分配一个较高的分数。
此外，我们更新了嵌入编码器的参数，以最大限度地提高域分类损失
L
d
i
s
L_{\mathrm{dis}}
Ldis，这对域鉴别器是不利的。因此，当
Ψ
src
\Psi_{\text {src}}
Ψsrc的输出与
Ψ
t
a
r
\Psi_{\mathrm{tar}}
Ψtar的输出无法区分时，我们期望模型能够学习到能够跨域泛化的特性和结构。嵌入编码器的损失函数
L
e
n
c
L_{\mathrm{enc}}
Lenc的表达式为
L
e
n
c
=
L
q
a
−
λ
G
L
d
i
s
L_{\mathrm{enc}}=L_{\mathrm{qa}}-\lambda_{G} L_{\mathrm{dis}}
Lenc=Lqa−λGLdis
其中
λ
G
\lambda_{G}
λG为超参数。对QA模型中的两个嵌入编码器进行学习以最大化
L
dis
L_{\text {dis }}
Ldis 减小QA的损失
L
q
a
L_{\mathrm{qa}}
Lqa。 由于QA模型中其他层的参数与域鉴别器的loss无关，所以其他层的loss 函数等价于
L
q
a
L_{\mathrm{qa}}
Lqa ，即
L
o
t
h
e
r
=
L
q
a
L_{\mathrm{other}}=L_{\mathrm{qa}}
Lother=Lqa
SpeechBERT
图 23 图23 图23
但更进一步，我们真的需要语音辨识吗？有没有可能跳过语音辨识，做一个端到端的语音QA，SpeechBERT便是如此，“硬train一发”。当然，这样做得到的正确率是差于做语音辨识的语音版QA的。但这两种是可以互补使用的，在语音辨识部分效果差的语音QA便通过这种端到端的方法解决，语音辨识部分效果好的依旧是文字版QA11。
来源为多种
图 24 图24 图24
刚刚上述讲的来源都是来自同一种类型的，那有没有可能从多个来源来训练QA呢？
有这样一种Movie QA，它的来源有影像（图片）、字幕（文字）、音频（声音）。回答一个问题是来自这三种资讯的。
QACNN
在这个问题的回答任务中，有一篇阅读文章，一个问题和几个选项。 P \mathbf{P} P表示段落， Q \mathbf{Q} Q表示查询， C \mathbf{C} C表示多项选择之一。该模型的目标是根据 P \mathbf{P} P和 Q \mathbf{Q} Q的信息从多项选择中选择正确的答案。
图 25 图25 图25
图25为QACNN的流程概况。首先， 使用嵌入层将 P 、 Q \mathbf{P}、\mathbf{Q} P、Q和 C \mathbf{C} C转换为单词嵌入。比较层生成文章查询相似度映射 P Q P Q PQ和文章选择相似度映射 P C P C PC。
然后是QACNN的主要组成部分。它由两阶段CNN架构组成。第一阶段将词级特征投射到句子级，第二阶段将句子级特征投射到篇章级。在词级和句子级的 P Q P Q PQ特征的基础上，对每个阶段分别应用基于查询的注意机制来识别相似映射，最终识别出查询的特定句法结构。通过将文章查询特征转化为注意映射，并将其应用到文章选择匹配结果中，合理地赋予文章中每个词的权重。
经过QACNN层，得到了每个选择答案特征。最后，预测层从每个选择特征收集输出信息，并返回最可能的答案。
- 相似映射层
相似性映射层由两部分组成:嵌入层和比较层。给定一个带有
N
N
N句子的段落
P
\mathbf{P}
P，一个查询
Q
\mathbf{Q}
Q，一个选择
C
\mathbf{C}
C，嵌入层将
P
，
Q
\mathbf{P}， \mathbf{Q}
P，Q和
C
\mathbf{C}
C中的每个单词转换为单词嵌入:
P
=
{
p
n
i
}
i
=
1
,
n
=
1
I
,
N
Q
=
{
q
j
}
j
=
1
J
C
=
{
c
k
}
k
=
1
K
\begin{array}{l} \boldsymbol{P}=\left\{p_{n}^{i}\right\}_{i=1, n=1}^{I, N} \\ \boldsymbol{Q}=\left\{q^{j}\right\}_{j=1}^{J} \\ \boldsymbol{C}=\left\{c^{k}\right\}_{k=1}^{K} \end{array}
P={pni}i=1,n=1I,NQ={qj}j=1JC={ck}k=1K
I
I
I为段落中句子的长度，
J
J
J和
K
K
K分别为查询的长度和单个选项的长度。
p n i , q j p_{n}^{i}, q^{j} pni,qj和 c k c^{k} ck 是 word embeddings.
任何类型的嵌入技术都可以获得单词的嵌入，如递归神经网络、序列到序列模型、Word2vec等。
然后比较层 获得相似度映射，告诉文章与查询、文章和选择之间的位置关系， 如图26所示，分别在单词层面对每个段落每个段落句子
P
n
P_{n}
Pn与
Q
Q
Q和
C
C
C进行比较。
P
n
Q
=
{
cos
(
p
n
i
,
q
j
)
}
i
=
1
,
j
=
1
I
,
J
P
n
C
=
{
cos
(
p
n
i
,
c
k
)
}
i
=
1
,
k
=
1
I
,
K
\begin{aligned} \boldsymbol{P}_{\boldsymbol{n}} \boldsymbol{Q} &=\left\{\cos \left(p_{n}^{i}, q^{j}\right)\right\}_{i=1, j=1}^{I, J} \\ \boldsymbol{P}_{\boldsymbol{n}} \boldsymbol{C} &=\left\{\cos \left(p_{n}^{i}, c^{k}\right)\right\}_{i=1, k=1}^{I, K} \end{aligned}
PnQPnC={cos(pni,qj)}i=1,j=1I,J={cos(pni,ck)}i=1,k=1I,K
图
26
图26
图26
也就是说， 将文章中句子中的每个单词与查询和选择中的每个单词进行比较。 使用余弦相似度作为比较方法。这一步创建了两个相似映射，段落查询相似映射
P
Q
=
P Q=
PQ=
[
P
1
Q
,
P
2
Q
,
…
,
P
N
Q
]
∈
R
N
×
J
×
I
\left[P_{1} Q, P_{2} Q, \ldots, P_{N} Q\right] \in \mathbb{R}^{N \times J \times I}
[P1Q,P2Q,…,PNQ]∈RN×J×I和段落选择相似映射
P
C
=
[
P
1
C
,
P
2
C
,
…
,
P
N
C
]
∈
R
N
×
K
×
I
\boldsymbol{P C}=\left[\boldsymbol{P}_{1} \boldsymbol{C}, \boldsymbol{P}_{2} \boldsymbol{C}, \ldots, P_{N} \boldsymbol{C}\right] \in \mathbb{R}^{N \times K \times I}
PC=[P1C,P2C,…,PNC]∈RN×K×I
- QACNN Layer
一个注意卷积匹配层来整合上面给出的两个相似图。即使用QACNN Layer来学习位置关系模式。它包含一个两阶段CNN，并结合基于查询的注意机制。每个阶段包括两个主要部分:注意图和输出表示。
2.1. 第一阶段注意映射
图
27
图27
图27
图27为第一阶段CNN注意力映射的结构。 在
P
Q
P Q
PQ选择
n
th
n^{\text {th}}
nth句子切片
P
n
Q
∈
R
J
×
I
P_{n} Q \in \mathbb{R}^{J \times I}
PnQ∈RJ×I，喂给CNN,其卷积核为
W
1
A
∈
\boldsymbol{W}_{1}^{\boldsymbol{A}} \in
W1A∈
R
J
×
l
×
d
\mathbb{R}^{J \times l \times d}
RJ×l×d,
其中，上标
A
\boldsymbol{A}
A表示注意图，下标1表示第一阶段CNN。符号
d
d
d和
l
l
l分别表示核的宽度和核的个数。生成的特征
q
n
A
∈
R
l
×
(
I
−
d
+
1
)
\boldsymbol{q}_{n}^{\boldsymbol{A}} \in \mathbb{R}^{l \times(I-d+1)}
qnA∈Rl×(I−d+1)如下:
q
n
A
=
sigmoid
(
W
1
A
∗
P
n
Q
+
b
1
A
)
q_{n}^{A}=\operatorname{sigmoid}\left(W_{1}^{A} * P_{n} Q+b_{1}^{A}\right)
qnA=sigmoid(W1A∗PnQ+b1A)
其中
b
1
A
∈
R
l
b_{1}^{A} \in \mathbb{R}^{l}
b1A∈Rl 。 当
W
1
A
W_{1}^{A}
W1A覆盖整个查询和段落中的几个单词时，卷积内核会学习查询的语法结构，并对每个段落的位置赋值。
这就是为什么在这个阶段使用sigmoid函数作为激活函数。此外，还使用maxpool kernel形状为 l l l，垂直地对 q n A q_{n}^{A} qnA进行maxpool运算，找出同一位置不同内核之间的最大权值，然后为每个句子生成单词级的注意映射 a n ∈ R I − d + 1 a_{n} \in \mathbb{R}^{I-d+1} an∈RI−d+1 。
2.2. 第一阶段的输出表征
图
28
图28
图28
为了取段落的句子特征，将CNN应用到 P n C P_{n} C PnC中，聚合位置关系模式，获得基于选择的句子特征。然后将CNN应用到 P n Q P_{n} Q PnQ中，获得基于查询的句子特征。
图28的输出表征部分的CNN架构与注意映射部分类似，但使用了不同的卷积核
W
1
R
∈
R
l
×
K
×
d
\boldsymbol{W}_{\mathbf{1}}^{\boldsymbol{R}} \in \mathbb{R}^{l \times K \times d}
W1R∈Rl×K×d中和不同的偏置
b
1
R
∈
R
l
\boldsymbol{b}_{\mathbf{1}}^{R} \in \mathbb{R}^{l}
b1R∈Rl :
q
n
R
=
Re
L
U
(
W
1
R
∗
P
n
Q
+
b
1
R
)
c
n
R
=
Re
L
U
(
W
1
R
∗
P
n
C
+
b
1
R
)
\begin{aligned} q_{n}^{R} &=\operatorname{Re} L U\left(W_{1}^{R} * P_{n} Q+b_{1}^{R}\right) \\ c_{n}^{R} &=\operatorname{Re} L U\left(W_{1}^{R} * P_{n} C+b_{1}^{R}\right) \end{aligned}
qnRcnR=ReLU(W1R∗PnQ+b1R)=ReLU(W1R∗PnC+b1R)
其中上标
R
R
R表示输出表征。
q
n
R
\boldsymbol{q}_{n}^{\boldsymbol{R}}
qnR 和
c
n
R
∈
R
l
×
(
I
−
d
+
1
)
c_{n}^{R} \in \mathbb{R}^{l \times(I-d+1)}
cnR∈Rl×(I−d+1)
然后， 将 c n R c_{n}^{R} cnR 逐个元素乘以单词级的注意映射 a n \boldsymbol{a}_{n} an，
最后进行maxpool q n R \boldsymbol{q}_{n}^{\boldsymbol{R}} qnR 和 c n R \boldsymbol{c}_{\boldsymbol{n}}^{\boldsymbol{R}} cnR 与卷积核形状 ( I − d + 1 ) (I-d+1) (I−d+1) ，获取基于查询的句子特征 r n P Q \boldsymbol{r}_{n}^{P Q} rnPQ 和基于选择的句子特征 r n P C ∈ R l \boldsymbol{r}_{\boldsymbol{n}}^{\boldsymbol{P} \boldsymbol{C}} \in \mathbb{R}^{l} rnPC∈Rl
2.3. 第二阶段注意映射
图
29
图29
图29
图29是第二阶段CNN注意力映射的架构。基于2.2中查询的句子特征，希望获得句子级的注意映射。这个阶段的输入是
r
P
Q
=
[
r
1
P
Q
,
r
2
P
Q
,
…
,
r
N
P
Q
]
\boldsymbol{r}^{P Q}=\left[\boldsymbol{r}_{1}^{P Q}, \boldsymbol{r}_{2}^{P Q}, \ldots, \boldsymbol{r}_{\boldsymbol{N}}^{P Q}\right]
rPQ=[r1PQ,r2PQ,…,rNPQ] :
q
^
A
=
sigmoid
(
W
2
A
∗
r
P
Q
+
b
2
A
)
\begin{array}{l} \hat{\boldsymbol{q}}^{\boldsymbol{A}}=\operatorname{sigmoid}\left(\boldsymbol{W}_{2}^{\boldsymbol{A}} * \boldsymbol{r}^{P Q}+\boldsymbol{b}_{2}^{A}\right) \end{array}
q^A=sigmoid(W2A∗rPQ+b2A)
生成中间特征
q
^
A
∈
R
l
×
(
N
−
d
+
1
)
\hat{\boldsymbol{q}}^{\boldsymbol{A}} \in \mathbb{R}^{l \times(N-\boldsymbol{d}+1)}
q^A∈Rl×(N−d+1)
然后，与第一阶段的注意映射相同，使用maxpool 对 q ^ A \hat{q}^{A} q^A 进行的池化核形状 l l l，得到句子级的注意映射 a ^ ∈ \hat{\boldsymbol{a}} \in a^∈ R N − d + 1 \mathbb{R}^{N-d+1} RN−d+1
2.4.第二阶段的输出表征
图
30
图30
图30
图30中第二阶段的输出表征部分有两个输入，句子级注意映射
a
^
\hat{a}
a^和句子级特征
r
P
C
=
[
r
1
P
C
,
r
2
P
C
,
…
,
r
N
P
C
]
\boldsymbol{r}^{P C}=\left[\boldsymbol{r}_{1}^{P C}, \boldsymbol{r}_{2}^{P C}, \ldots, \boldsymbol{r}_{\boldsymbol{N}}^{P C}\right]
rPC=[r1PC,r2PC,…,rNPC]，这里的方程与前面提到的类似。遵循:
c
^
R
=
R
e
L
U
(
W
2
R
∗
r
P
C
+
b
2
R
)
r
^
=
{
max
(
c
^
t
R
⋅
a
^
)
}
t
=
1
l
\begin{array}{l} \hat{\boldsymbol{c}}^{R}=\boldsymbol{R e} \boldsymbol{L} \boldsymbol{U}\left(\boldsymbol{W}_{2}^{\boldsymbol{R}} * \boldsymbol{r}^{P C}+\boldsymbol{b}_{2}^{R}\right) \\ \hat{\boldsymbol{r}}=\left\{\max \left(\hat{\boldsymbol{c}}_{t}^{R} \cdot \hat{\boldsymbol{a}}\right)\right\}_{t=1}^{l} \end{array}
c^R=ReLU(W2R∗rPC+b2R)r^={max(c^tR⋅a^)}t=1l
其中
W
2
R
∈
R
l
×
l
×
d
,
b
2
R
∈
R
l
\boldsymbol{W}_{\mathbf{2}}^{\boldsymbol{R}} \in \mathbb{R}^{l \times l \times d}, \boldsymbol{b}_{\mathbf{2}}^{\boldsymbol{R}} \in \mathbb{R}^{l}
W2R∈Rl×l×d,b2R∈Rl,
c
^
R
∈
R
l
×
(
N
−
d
+
1
)
\hat{\boldsymbol{c}}^{\boldsymbol{R}} \in \mathbb{R}^{l \times(N-\boldsymbol{d}+\mathbf{1})}
c^R∈Rl×(N−d+1)
特定选择的输出表征 r ^ ∈ R l \hat{\boldsymbol{r}} \in \mathbb{R}^{l} r^∈Rl 是 QACNN 最后的输出层
- 预测层
预测层是QACNN的最后一部分。使用
r
^
m
∈
R
l
\hat{\boldsymbol{r}}_{\boldsymbol{m}} \in \mathbf{R}^{l}
r^m∈Rl来表示
m
t
h
m^{t h}
mth选项的最终输出表征。为了找出最正确的选择，只需将
r
^
m
\hat{\boldsymbol{r}}_{\boldsymbol{m}}
r^m传递给两个完全连接的层，并使用softmax计算每个选择的概率，如下所述:
R
=
{
r
^
m
}
m
=
1
M
p
(
m
∣
R
)
=
softmax
(
W
o
(
tanh
(
W
p
R
+
b
p
)
)
+
b
o
)
\begin{array}{c} \boldsymbol{R}=\left\{\hat{\boldsymbol{r}}_{m}\right\}_{m=1}^{M} \\ \boldsymbol{p}(\boldsymbol{m} \mid \boldsymbol{R})=\operatorname{softmax}\left(\boldsymbol{W}^{o}\left(\tanh \left(\boldsymbol{W}^{p} \boldsymbol{R}+\boldsymbol{b}^{p}\right)\right)+\boldsymbol{b}^{o}\right) \end{array}
R={r^m}m=1Mp(m∣R)=softmax(Wo(tanh(WpR+bp))+bo)
W
p
∈
R
l
×
l
,
b
p
∈
R
l
,
W
o
∈
R
l
\boldsymbol{W}^{\boldsymbol{p}} \in \mathbb{R}^{l \times l}, \boldsymbol{b}^{\boldsymbol{p}} \in \mathbb{R}^{l}, \boldsymbol{W}^{\boldsymbol{o}} \in \mathbb{R}^{l}
Wp∈Rl×l,bp∈Rl,Wo∈Rl,
b
o
∈
R
\boldsymbol{b}^{o} \in \mathbb{R}
bo∈R.
参考
李宏毅，机器学习课程
【问答总结】开放领域问答梳理系列(1)
TOWARDS AI-COMPLETE QUESTION ANSWERING : A SET OF PREREQUISITE TOY TASKS ↩︎
SQuAD: 100,000+ Questions for Machine Comprehension of Text ↩︎
MS MARCO: A Human Generated MAchine Reading COmprehension Dataset ↩︎
S-NET: FROM ANSWER EXTRACTION TO ANSWER GENERATION FOR MACHINE READING COMPREHEN SION ↩︎
BERT: Pre-training of Deep Bidirectional Transformers for Language Understanding ↩︎
Read + Verify: Machine Reading Comprehension with Unanswerable Questions ↩︎
Stochastic Answer Networks for SQuAD 2.0 ↩︎
Multi-Passage Machine Reading Comprehension with Cross-Passage Answer Verification ↩︎ ↩︎
Spoken SQuAD: A Study of Mitigating the Impact of Speech Recognition Errors on Listening Comprehension ↩︎
MITIGATING THE IMPACT OF SPEECH RECOGNITION ERRORS ON SPOKEN QUESTION ANSWERING BY ADVERSARIAL DOMAIN ADAPTATION ↩︎
SpeechBERT: An Audio-and-text Jointly Learned Language Model for End-to-end Spoken Question Answering ↩︎
标签：boldsymbol,right,exp,text,Answering,Question,答案,13.1,left 来源： https://blog.csdn.net/qq_43940950/article/details/116570815
本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享； 2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关； 3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关； 4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除； 5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。