排序系列篇：
- 排序之指标集锦(系列1)
- 原创 排序之损失函数pair-wise loss(系列2)
- 排序之损失函数List-wise loss(系列3)
最早的关于list-wise的文章发表在Learning to Rank: From Pairwise Approach to Listwise Approach中，后面陆陆续续出了各种变形，但是也是万变不离其宗，本文梳理重在原理。
论文链接listNet，参考的实现代码：实现代码
1. 为什么要List-wise loss
pairwise优缺点
优点：
- 一些已经被验证的较好的分类模型可以直接拿来用。
- 在一些特定场景下，其pairwise features 很容易就可以获得。
缺点：
- 其学习的目标是最小化文档对的分类错误，而不是最小化文档排序的错误。学习目标和实际目标（MAE,NDCG）有所违背。
- 训练过程可能是极其耗时的，因为生成的文档对样本数量可能会非常多。
那么本篇论文是如何解决这些问题呢？
在pointwise 中，我们将每一个<query, document> 作为一个训练样本来训练一个分类模型。这种方法没有考虑文档之间的顺序关系；而在pariwise 方法中考虑了同一个query 下的任意两个文档的相关性，但同样有上面已经讲过的缺点；在listwise 中，我们将一个<query,documents> 作为一个样本来训练，其中documents 为与这个query 相关的文件列表。
论文中还提出了概率分布的方法来计算listwise 的损失函数。并提出了permutation probability 和top one probability 两种方法。下面会详述这两种方法。
2. 方法介绍
2.1. loss输入格式
假设我们有m 个 querys：
Q
=
(
q
(
1
)
,
q
(
2
)
,
q
(
3
)
,
.
.
.
,
q
(
m
)
)
Q=(q^{(1)}, q^{(2)}, q^{(3)},...,q^{(m)})
Q=(q(1),q(2),q(3),...,q(m))
每个query 下面有n 个可能与之相关的文档（对于不同的query ，其n 可能不同）
d
(
i
)
=
(
d
1
(
i
)
,
d
2
(
i
)
,
.
.
.
,
d
n
(
i
)
)
d^{(i)} = (d^{(i)}_1, d^{(i)}_2, ..., d^{(i)}_n)
d(i)=(d1(i),d2(i),...,dn(i))
对于每个query 下的所有文档，我们可以根据具体的应用场景得到每个文档与query 的真实相关度得分。
y
(
i
)
=
(
y
1
(
i
)
,
y
2
(
i
)
,
.
.
.
.
,
y
n
(
i
)
)
y^{(i)} = (y^{(i)}_1, y^{(i)}_2, ...., y^{(i)}_n)
y(i)=(y1(i),y2(i),....,yn(i))
我们可以从每一个文档对
(
q
(
i
)
,
d
j
(
i
)
)
(q^{(i)}, d^{(i)}_{j})
(q(i),dj(i))得到该文档的打分，
q
(
i
)
q^{(i)}
q(i)与文档集合
d
(
i
)
d^{(i)}
d(i)中的每个文档打分，可以得到该query 下的所有文档的特征向量：
x
(
i
)
=
(
x
1
(
i
)
,
x
2
(
i
)
,
.
.
.
,
x
n
(
i
)
)
x^{(i)} = (x^{(i)}_1, x^{(i)}_2, ..., x^{(i)}_n)
x(i)=(x1(i),x2(i),...,xn(i))
并且在已知每个文档真实相关度得分的条件下：
y
(
i
)
=
(
y
1
(
i
)
,
y
2
(
i
)
,
.
.
.
,
y
n
(
i
)
)
y^{(i)} = (y^{(i)}_1, y^{(i)}_2, ..., y^{(i)}_n)
y(i)=(y1(i),y2(i),...,yn(i))
我们可以构建训练样本：
T
=
{
(
x
(
i
)
,
y
(
i
)
)
}
T=\begin{Bmatrix} (x^{(i)}, y^{(i)}) \end{Bmatrix}
T={(x(i),y(i))}
要特别注意的是：这里面一个训练样本是
(
x
(
i
)
,
y
(
i
)
)
(x^{(i)}, y^{(i)})
(x(i),y(i))，而这里的
x
(
i
)
x^{(i)}
x(i)是一个与query 相关的文档列表，这也是区别于pointwise 和pairwise 的一个重要特征。
关于
y ( i ) y^{(i)} y(i)paper里面的相关描述：
2.2. loss计算
那么有训练样本了，如何计算loss 呢？
假设我们已经有了排序函数 f ff，我们可以计算特征向量
x
(
i
)
x^{(i)}
x(i)的得分情况：
z
(
i
)
=
(
f
(
x
1
(
i
)
)
,
f
(
x
2
(
i
)
)
,
.
.
.
,
f
(
x
n
(
i
)
)
)
z^{(i)} = (f(x_1^{(i)}), f(x_2^{(i)}), ..., f(x_n^{(i)}))
z(i)=(f(x1(i)),f(x2(i)),...,f(xn(i)))
显然我们学习的目标就是，最小化真实得分和预测得分的误差：
∑
i
=
1
m
L
(
y
(
i
)
,
z
(
i
)
)
\sum_{i=1}^{m} L(y^{(i)}, z^{(i)})
i=1∑mL(y(i),z(i))
L 为 listwise 的损失函数。
2.2.1. 概率模型
假设对于某一个query 而言，与之可能相关的文档有
{
1
,
2
,
3
,
.
.
.
,
n
}
\{1, 2, 3, ..., n\}
{1,2,3,...,n}，假设某一种排序的结果为
π
\pi
π
π
=
<
π
(
1
)
,
π
(
2
)
,
.
.
,
π
(
n
)
>
\pi=<\pi(1), \pi(2), .., \pi(n)>
π=<π(1),π(2),..,π(n)>
对于n 个文档，有n! 种排列情况。这所有的排序情况记为
Ω
n
\Omega_n
Ωn。假设已有排序函数，那么对于每个文档，我们都可以计算出相关性得分
s
=
(
s
1
,
s
2
,
.
.
.
,
s
n
)
s = (s_1, s_2, ..., s_n)
s=(s1,s2,...,sn)。 显然对于每一种排序情况，都是有可能发生的，但是每一种排列都有其最大似然值。
我们可以这样定义某一种排列
π
\pi
π的概率（最大似然值）：
P
s
(
π
)
=
∏
j
=
1
n
ϕ
(
s
π
(
j
)
)
∑
k
=
j
n
ϕ
(
s
π
(
k
)
)
P_s(\pi) = \prod_{j=1}^{n} \frac{\phi (s_{\pi(j)})}{\sum_{k=j}^{n}\phi(s_{\pi(k)})}
Ps(π)=j=1∏n∑k=jnϕ(sπ(k))ϕ(sπ(j))
其中
ϕ
\phi
ϕ表示对分数的归一化处理。
例如有三个文档
π
=
<
1
,
2
,
3
>
\pi = <1,2,3>
π=<1,2,3> ，其排序函数计算每个文档得分为
s
=
(
s
1
,
s
2
,
s
3
)
s=(s_1, s_2, s_3)
s=(s1,s2,s3)，则该种排序概率为：
P
s
(
π
)
=
ϕ
(
s
1
)
ϕ
(
s
1
)
+
ϕ
(
s
2
)
+
ϕ
(
s
3
)
⋅
ϕ
(
s
2
)
ϕ
(
s
2
)
+
ϕ
(
s
3
)
⋅
ϕ
(
s
3
)
ϕ
(
s
3
)
P_s(\pi) =\frac{\phi(s_1)}{\phi(s_1)+\phi(s_2)+\phi(s_3)} \cdot \frac{\phi(s_2)}{\phi(s_2)+\phi(s_3)} \cdot \frac{\phi(s_3)}{\phi(s_3)}
Ps(π)=ϕ(s1)+ϕ(s2)+ϕ(s3)ϕ(s1)⋅ϕ(s2)+ϕ(s3)ϕ(s2)⋅ϕ(s3)ϕ(s3)
对于另外一种排序，例如
π
′
=
<
3
,
2
,
1
>
{\pi}' = <3,2,1>
π′=<3,2,1> ，则这种排列概率为：
P
s
(
π
)
=
ϕ
(
s
3
)
ϕ
(
s
3
)
+
ϕ
(
s
2
)
+
ϕ
(
s
1
)
⋅
ϕ
(
s
2
)
ϕ
(
s
2
)
+
ϕ
(
s
3
)
⋅
ϕ
(
s
1
)
ϕ
(
s
1
)
P_s(\pi) =\frac{\phi(s_3)}{\phi(s_3)+\phi(s_2)+\phi(s_1)} \cdot \frac{\phi(s_2)}{\phi(s_2)+\phi(s_3)} \cdot \frac{\phi(s_1)}{\phi(s_1)}
Ps(π)=ϕ(s3)+ϕ(s2)+ϕ(s1)ϕ(s3)⋅ϕ(s2)+ϕ(s3)ϕ(s2)⋅ϕ(s1)ϕ(s1)
很明显，< 3,2,1 >这个排序的打分最低，< 1,2,3 >这个排序的打分最高。
2.2.2. Top K Probability
上面那种计算排列概率的方式，其计算复杂度达到
n
!
n!
n!，太耗时间，由此论文中提出了一种更有效率的方法 top one。我们在这里推广到top k来分析总结。
上面计算某一种排序方式概率：
P
s
(
π
)
=
∏
j
=
1
n
ϕ
(
s
π
(
j
)
)
∑
k
=
j
n
ϕ
(
s
π
(
k
)
)
P_s(\pi) = \prod_{j=1}^{n} \frac{\phi (s_{\pi(j)})}{\sum_{k=j}^{n}\phi(s_{\pi(k)})}
Ps(π)=j=1∏n∑k=jnϕ(sπ(k))ϕ(sπ(j))
排在第一位的有
n
n
n 种情况，排在第二位的有
n
−
1
n−1
n−1 种情况，后面依次类推。相当与利用 top
n
n
n来计算。
那么 top
K
(
K
<
n
)
K(K<n)
K(K<n)计算：
P
s
(
π
)
=
∏
j
=
1
K
ϕ
(
s
π
(
j
)
)
∑
k
=
j
n
ϕ
(
s
π
(
k
)
)
P_s(\pi) = \prod_{j=1}^{K} \frac{\phi (s_{\pi(j)})}{\sum_{k=j}^{n}\phi(s_{\pi(k)})}
Ps(π)=j=1∏K∑k=jnϕ(sπ(k))ϕ(sπ(j))
同理，这里的计算复杂度为
n
∗
(
n
−
1
)
∗
(
n
−
2
)
∗
.
.
.
∗
(
n
−
k
+
1
)
n∗(n−1)∗(n−2)∗...∗(n−k+1)
n∗(n−1)∗(n−2)∗...∗(n−k+1)，即为
N
!
/
(
N
−
k
)
!
N!/(N-k)!
N!/(N−k)!种不同排列，大大减少了计算复杂度。
如果
K
=
1
K=1
K=1，就蜕变成论文中top 1 的情况，此时有 n 种不同排列情况：
P
s
(
π
)
=
ϕ
(
s
π
(
j
)
)
∑
k
=
j
n
ϕ
(
s
π
(
k
)
)
P_s(\pi) = \frac{\phi (s_{\pi(j)})}{\sum_{k=j}^{n}\phi(s_{\pi(k)})}
Ps(π)=∑k=jnϕ(sπ(k))ϕ(sπ(j))
对于
N
!
/
(
N
−
k
)
!
N!/(N-k)!
N!/(N−k)!种不同的排列情况，就有 N!/(N−k)! 个排列预测概率，就形成了一种概率分布，再由真实的相关性得分计算相应的排列概率，得到真实的排列概率分布。由此可以利用 cross−entropy 来计算两种分布的距离作为损失函数：
L
(
y
(
i
)
,
z
(
i
)
)
=
−
∑
j
=
1
n
{
P
y
(
i
)
(
j
)
∗
l
o
g
(
P
z
(
i
)
(
j
)
)
}
L(y^{(i)}, z^{(i)}) = - \sum_{j=1}^{n} \{P_{y^{(i)}}(j) *log(P_{z^{(i)}}(j))\}
L(y(i),z(i))=−j=1∑n{Py(i)(j)∗log(Pz(i)(j))}
例如一个查询下有三个文档
<
A
,
B
,
C
>
<A,B,C>
<A,B,C>：
上图中 g 为有真实打分计算出的各种排列的概率分布， f、h 为另外两种排列概率分布，我们就是需要比较那种排列概率分布与真实的排列概率分布更为接近，就用该分布的预测相关性得分作为最终得分。
2.2.3. ListNet
这里给出ListNet最终的形式
在论文中，Listnet只是将上面的
t
o
p
K
topK
topK 中的
ϕ
\phi
ϕ函数变成 exp 函数:
P
s
(
π
)
=
exp
(
s
π
(
j
)
)
∑
k
=
j
n
exp
(
s
π
(
k
)
)
P_s(\pi) = \frac{\exp (s_{\pi(j)})}{\sum_{k=j}^{n}\exp(s_{\pi(k)})}
Ps(π)=∑k=jnexp(sπ(k))exp(sπ(j))
这样不就是计算预测出的得分的softmax 了吗？实际上的确如此，在实现代码中就是这样做的，当时我直接看代码还一脸懵逼，这不就是对文档预测出来的得分做了个softmax 操作吗？跟top−one 有什么关系，仔细看论文才知道怎么回事。
top−1 时，只有n 种排列情况，这大大减少了计算量。如果top
K
(
K
>
1
)
K (K>1)
K(K>1)，则需要计算的排列情况就会变多。
假设排序函数 f 的参数为w ，则 top-one 的排列概率分布为：
P
z
(
i
)
(
f
w
)
(
x
j
(
i
)
)
=
exp
(
f
w
(
x
j
(
i
)
)
)
∑
k
=
j
n
exp
(
f
w
(
x
k
(
i
)
)
)
P_{z^{(i)}(f_w)}(x_j^{(i)}) = \frac{\exp (f_w(x_j^{(i)}))}{\sum_{k=j}^{n}\exp(f_w(x_k^{(i)}))}
Pz(i)(fw)(xj(i))=∑k=jnexp(fw(xk(i)))exp(fw(xj(i)))
这里还是需要注意：是将某一个查询下的所有可能与之相关的文档列表，作为一个样本来训练。
最终的损失函数：
L
(
y
(
i
)
,
z
(
i
)
(
f
w
)
)
=
−
∑
j
=
1
n
{
P
y
(
i
)
(
x
j
(
i
)
)
∗
l
o
g
(
P
z
(
i
)
(
f
w
)
(
x
j
(
i
)
)
)
}
L(y^{(i)}, z^{(i)}(f_w)) = - \sum_{j=1}^{n} \{P_{y^{(i)}}(x_j^{(i)}) *log(P_{z^{(i)}(f_w)}(x_j^{(i)}))\}
L(y(i),z(i)(fw))=−j=1∑n{Py(i)(xj(i))∗log(Pz(i)(fw)(xj(i)))}
小编总结：
简单来说， Listwise的loss其实从本质上可以归纳如下：
step1: 对所有包含正样本和负样本的集合进行softmax； step2: 在用交叉熵对所有样本求和计算loss
但是从原理上来说，其实这只是一个为了计算速度的折中。另外交叉熵中的groundtruth，也就是上面的y j ( i ) y^{(i)}_j yj(i)打分，这样groundtruth打分越高的，如果预测误差大导致的loss越大，从而对实际为高分但是预测为低分的关注度更高，从而提高top的打分。
实现细节
在看源码的时候发现了一个细节，paper里面说的是交叉熵，但是在代码实现中我发现用的是交叉熵，也就是红色里面是KL散度，而绿色才是交叉熵。
总结
在pairwise 中，只考虑了两个文档对的相对先后顺序，却没有考虑文档出现在搜索列表中的位置，排在搜索站果前列的文档更为重要，如果前列文档出现判断错误，代价明显高于排在后面的文档。针对这个问题的改进思路是引入代价敏感因素，即每个文档对根据其在列表中的顺序具有不同的权重，越是排在前列的权重越大，即在搜索列表前列，如果排错顺序的话其付出的代价更高(评价指标NDCG)； 而listwise 讲一个查询下的所有文档作为一个样本，因为要组合出不同的排列，得到其排列概率分布，来最小化与真实概率分布的误差，这里面就考虑了文档之间的各种顺序关系。很好的避免了这种情况。
从概率模型的角度定义损失函数。
在实做时，其实将一个query 下的的所有可能与之相关的n个doc作为一个训练样本（这时可以理解batch_size=n） ，一定要注意：在计算top_1 probability 时，是在一个query 内的所有文档做softmax ，而不是在当前正在训练的所有的样本内做。这是区别pointwise、pairwise 的重要不同之处。
参考链接：
论文分享— >Learning to Rank: From Pairwise Approach to Listwise Approach
版权归原作者 AI蜗牛之家 所有， 如有侵权，请联系我们删除。