|
CDAC+：通过深度自适应聚类发现新意图
《Discovering New Intents via Constrained Deep Adaptive Clustering with Cluster Refinement》
论文地址：https://arxiv.org/pdf/1911.08891.pdf
一、简介
-
意图发现 ? 发现用户未被满足的新意图是对话系统中的重要任务。通过将相似语料聚类成相同的簇，可以识别出新的商业机会，并决定系统未来的发展方向。由于许多对话数据是未标注的，一个好的聚类算法能够帮助自动发现合理的分类，识别潜在的用户需求。 ? 但是，实现这样的聚类算法面临两个挑战。
- 精准估计新意图的数量十分困难；
- 聚类的结果很难符合人的期望。例如，假设需要根据用户遇到的技术问题来划分数据，最终可能会按问题的类型进行聚类；
-
现有方法
-
Hakkani-Tur
\text{Hakkani-Tur}
Hakkani-Tur等人使用语义解决将用户的语料分解成图，然后基于频率和熵进行剪枝；
-
Padmasundari
\text{Padmasundari}
Padmasundari通过集成方法来合并不同聚类算法和表示方法的结果；
-
AutoDial
\text{AutoDial}
AutoDial抽取所有类型的特征(例如
POS
\text{POS}
POS标记和关键词)，然后使用层次聚类来聚合句子；
-
Haponchyk
\text{Haponchyk}
Haponchyk使用预定义的结构化输出来指导聚类过程；
但是，这些方法都需要密集的特征工程。此外，这些方法以pipeline的方式执行表示学习和簇分配，可能导致较差的效果。 -
解决方案 ? 实际场景中，存在着有限的标注数据和大量的无标注数据，且预先不知道所有的意图类别。此外，训练数据存在噪音，即无标注数据中既有已知意图，也有未知意图。关键是如何利用标注数据来有效地改进聚类效果。 ? 为了解决这些问题，本文提出了一种端到端的聚类方法
CDAC+
\text{CDAC+}
CDAC+，在聚类的过程中优化意图的向量表示。此外，还利用预训练语言模型
BERT
\text{BERT}
BERT和标注数据来帮助聚类过程。具体来说，整个方法划分为三个步骤。
- 首先，从
BERT
\text{BERT}
BERT获取意图的向量表示；(意图表示)
- 其次，构造成对分类任务来作为聚类的替代。使用意图表示来计算句子对的相似矩阵，然后使用相似与否的标签来训练网络；(成对分类)
- 最后，使用辅助
t
t
t分布和
KL
\text{KL}
KL散度来鼓励模型从高置信度分配中学习；(簇细化)
二、意图表示
? 使用预训练语言模型
BERT
\text{BERT}
BERT来获取意图向量表示。给定语料库中的第
i
i
i个句子
x
i
x_i
xi?，从
BERT
\text{BERT}
BERT的最后隐藏层获取所有token的嵌入向量
[
C
,
T
1
,
…
,
T
N
]
∈
R
(
N
+
1
)
×
H
[C,T_1,\dots,T_N]\in\mathbb{R}^{(N+1)\times H}
[C,T1?,…,TN?]∈R(N+1)×H。利用
mean-pooling
\text{mean-pooling}
mean-pooling来获得平均表示
e
i
∈
R
H
e_i\in\mathbb{R}^H
ei?∈RH：
e
i
=
mean-pooling
(
[
C
,
T
1
,
…
,
T
N
]
)
e_i=\text{mean-pooling}([C,T_1,\dots,T_N])
ei?=mean-pooling([C,T1?,…,TN?])
其中，
N
N
N是序列长度，
H
H
H是隐藏层大小。然后，将
e
i
e_i
ei?送入聚类层
g
g
g，并获得意图的向量表示
I
i
∈
R
k
I_i\in\mathbb{R}^k
Ii?∈Rk：
g
(
e
i
)
=
I
i
=
W
2
(
Dropout
(
tanh
(
W
1
e
i
)
)
)
g(e_i)=I_i=W_2(\text{Dropout}(\text{tanh}(W_1 e_i)))
g(ei?)=Ii?=W2?(Dropout(tanh(W1?ei?)))
其中，
W
1
∈
R
H
×
H
W_1\in\mathbb{R}^{H\times H}
W1?∈RH×H且
W
2
∈
R
H
×
k
W_2\in\mathbb{R}^{H\times k}
W2?∈RH×k是可学习参数，
k
k
k是簇数量。
三、成对分类
? 聚类的本质是衡量样本间的相似度。受模型
DAC
\text{DAC}
DAC的启发，本文将聚类问题重新为成对分类问题。通过学习句子是否相似，模型能够学习到有益于聚类的意图表示。使用意图向量表示
I
I
I来计算相似矩阵
S
S
S
S
i
j
=
I
i
I
j
T
∥
I
i
∥
∥
I
j
∥
S_{ij}=\frac{I_i I_j^T}{\parallel I_i \parallel\parallel I_j \parallel}
Sij?=∥Ii?∥∥Ij?∥Ii?IjT??
其中，
∥
?
∥
\parallel \cdot \parallel
∥?∥是
L2
\text{L2}
L2范数，并且
i
,
j
∈
{
1
,
…
,
n
}
i,j\in\{1,\dots,n\}
i,j∈{1,…,n}；batch size为n；
S
i
j
S_{ij}
Sij?表示句子
x
i
x_i
xi?和
x
j
x_j
xj?的相似度。然后，迭代地使用监督和自监督步骤来优化模型。
1. 监督步骤
? 给定少量的标注数据，构造标签矩阵
R
\text{R}
R
R
i
j
:
=
{
1
,
??
if
y
i
=
y
j
0
,
??
if
y
i
≠
y
j
,
R_{ij}:= \begin{cases} 1,\;\text{if}\quad y_i=y_j \\ 0,\;\text{if}\quad y_i\neq y_j, \end{cases}
Rij?:={1,ifyi?=yj?0,ifyi??=yj?,?
其中，
i
,
j
∈
{
1
,
…
,
n
}
i,j\in\{1,\dots,n\}
i,j∈{1,…,n}。使用相似矩阵
S
S
S和标签矩阵
R
R
R来计算损失函数
L
s
i
m
\mathcal{L}_{sim}
Lsim?：
L
s
i
m
(
R
i
j
,
S
i
j
)
=
?
R
i
j
log
(
S
i
j
)
?
(
1
?
R
i
j
)
log
(
1
?
S
i
j
)
\mathcal{L}_{sim}(R_{ij},S_{ij})=-R_{ij}\text{log}(S_{ij})-(1-R_{ij})\text{log}(1-S_{ij})
Lsim?(Rij?,Sij?)=?Rij?log(Sij?)?(1?Rij?)log(1?Sij?)
这里将标注数据作为先验，并使用它指导聚类过程。
2. 自监督步骤
? 通过相似矩阵
S
S
S上应用动态阈值，获取自标注矩阵
R
^
\hat{R}
R^
R
^
i
j
:
=
{
1
,
if
S
i
j
>
u
(
λ
)
??
or
??
y
i
=
y
j
0
,
if
S
i
j
<
l
(
λ
)
??
or
??
y
i
≠
y
j
Not?selected,?otherwise
\hat{R}_{ij}:= \begin{cases} 1,\text{if}\quad S_{ij}>u(\lambda)\;\text{or}\;y_i=y_j \\ 0,\text{if}\quad S_{ij}<l(\lambda)\;\text{or}\;y_i\neq y_j \\ \text{Not selected, otherwise} \end{cases}
R^ij?:=??????1,ifSij?>u(λ)oryi?=yj?0,ifSij?<l(λ)oryi??=yj?Not?selected,?otherwise?
其中，
i
,
j
∈
{
1
,
…
,
n
}
i,j\in\{1,\dots,n\}
i,j∈{1,…,n}。
u
(
λ
)
u(\lambda)
u(λ)是动态阈值上限，
l
(
λ
)
l(\lambda)
l(λ)是动态阈值下限，共同用来决定句子对是否相似。那些介于
u
(
λ
)
u(\lambda)
u(λ)和
l
(
λ
)
l(\lambda)
l(λ)的句子对不参与训练过程。在本步骤中，混合了标注和未标注数据来训练模型。
? 此外，添加
u
(
λ
)
?
l
(
λ
)
u(\lambda)-l(\lambda)
u(λ)?l(λ)作为样本数量的惩罚项
min
λ
??
E
(
λ
)
=
u
(
λ
)
?
l
(
λ
)
\mathop{\text{min}}_{\lambda}\;\textbf{E}(\lambda)=u(\lambda)-l(\lambda)
minλ?E(λ)=u(λ)?l(λ)
其中，
λ
\lambda
λ是一个控制样本选择的自适应参数，并且迭代更新
λ
\lambda
λ的值
λ
:
=
λ
?
η
?
?
E
(
λ
)
?
λ
\lambda:=\lambda-\eta\cdot\frac{\partial\textbf{E}(\lambda)}{\partial\lambda}
λ:=λ?η??λ?E(λ)?
其中，
η
\eta
η是
λ
\lambda
λ的学习率。由于
u
(
λ
)
∝
?
λ
u(\lambda)\propto -\lambda
u(λ)∝?λ且
l
(
λ
)
∝
λ
l(\lambda)\propto\lambda
l(λ)∝λ，可以在训练过程中增加
λ
\lambda
λ来降低
u
(
λ
)
u(\lambda)
u(λ)和提高
l
(
λ
)
l(\lambda)
l(λ)。这方便逐步地选择更多句子来参加训练过程。这当然也可能在
R
^
\hat{R}
R^中引入更多的噪音。
? 最后，使用相似度矩阵
S
S
S和自标注矩阵
R
^
\hat{R}
R^来计算损失函数
L
^
s
i
m
\hat{\mathcal{L}}_{sim}
L^sim?：
L
^
s
i
m
(
R
^
i
j
,
S
i
j
)
=
?
R
^
i
j
log
(
S
i
j
)
?
(
1
?
R
^
i
j
)
log
(
1
?
S
i
j
)
\hat{\mathcal{L}}_{sim}(\hat{R}_{ij},S_{ij})=-\hat{R}_{ij}\text{log}(S_{ij})-(1-\hat{R}_{ij})\text{log}(1-S_{ij})
L^sim?(R^ij?,Sij?)=?R^ij?log(Sij?)?(1?R^ij?)log(1?Sij?)
随着阈值的改变，模型会从学习简单分类句子到学习难分类句子对，迭代地获取有益于聚类的表示。当
u
(
λ
)
≤
l
(
λ
)
u(\lambda)\leq l(\lambda)
u(λ)≤l(λ)时，停止迭代并移动到细化阶段。
四、簇细化
? 这部分的逻辑与模型DEC完全相同。
? 通过期望最大化方法迭代的细化簇分配，鼓励模型来学习高置信度的分配。首先，给定初始化的簇中心
U
∈
R
k
×
k
U\in\mathbb{R}^{k\times k}
U∈Rk×k，计算意图向量表示和簇中心的软分配。具体来说，使用学生
t
t
t分布作为评估意图向量表示
I
i
I_i
Ii?和簇中心
U
j
U_j
Uj?的相似度
Q
i
j
=
(
1
+
∥
I
i
?
U
j
∥
2
)
?
1
∑
j
′
(
1
+
∥
I
i
?
U
j
∥
2
)
?
1
Q_{ij}=\frac{(1+\parallel I_i-U_j \parallel^2)^{-1}}{\sum_{j'}(1+\parallel I_i-U_j \parallel^2)^{-1}}
Qij?=∑j′?(1+∥Ii??Uj?∥2)?1(1+∥Ii??Uj?∥2)?1?
其中，
Q
i
j
Q_{ij}
Qij?表示样本
i
i
i属于簇
j
j
j的概率。
? 其次，使用辅助目标分布
P
P
P来强迫模型来学习高置信度分配，从而细化了模型参数和簇中心。定义目标分布
P
P
P如下：
P
i
j
=
Q
i
j
2
/
f
i
∑
j
′
Q
i
j
′
2
/
f
j
′
P_{ij}=\frac{Q_{ij}^2/f_i}{\sum_{j'}Q_{ij'}^2/f_{j'}}
Pij?=∑j′?Qij′2?/fj′?Qij2?/fi??
其中
f
i
=
∑
i
Q
i
j
f_i=\sum_{i}Q_{ij}
fi?=∑i?Qij?表示软簇频率。
? 最后，最小化
P
P
P和
Q
Q
Q的
KLD
\text{KLD}
KLD损失函数
L
KLD
=
K
L
(
P
∥
Q
)
=
∑
i
∑
j
P
i
j
log
P
i
j
Q
i
j
\mathcal{L}_{\text{KLD}}=KL(P\parallel Q)=\sum_i\sum_j P_{ij}\text{log}\frac{P_{ij}}{Q_{ij}}
LKLD?=KL(P∥Q)=i∑?j∑?Pij?logQij?Pij??
然后，重复上面的两个步骤直至在两次连续迭代中，簇分配的改变小于
δ
l
a
b
l
e
%
\delta_{lable}\%
δlable?%。
? 推断簇中心
c
i
c_i
ci?如下：
c
i
=
argmax
k
??
Q
i
k
c_i=\mathop{\text{argmax}}_k\;Q_{ik}
ci?=argmaxk?Qik?
其中，
c
i
c_i
ci?是句子
x
i
x_i
xi?的簇分配。
|