Factorization Machine

文章来自：深入FFM原理与实践

【动机】

特征的交叉是有用的，于是想到构造二次项特征，对应着如下的多项式模型
$\begin{aligned}y(\mathbf{x})=w_0+\sum\limits_{i=1}^{n}w_ix_i+\sum\limits_{i=1}^{n}\sum\limits_{j=i+1}^{n}w_{ij}\, x_ix_j\end{aligned}$

参数包括：$w_0$，$\begin{bmatrix}w_1\\ w_2\\ \vdots \\ w_n\end{bmatrix}$，$W=\begin{bmatrix}- & w_{12} & w_{13} & \cdots & w_{1n} \\ & - & w_{23} & \cdots & w_{2n} \\ & & - & \cdots & \vdots \\ & & & - & w_{n-1,n} \\ & & & & -\end{bmatrix}$
其中矩阵$W$包含$\begin{aligned}(n-1)+(n-2)+\cdots+2+1=\frac{n(n-1)}{2}\end{aligned}$个参数

对于参数$w_{ij}$，只有当特征$x_i$和$x_j$都非$0$时，才产生loss，因此$w_{ij}$需要大量$x_i$和$x_j$都非0的样本才能进行训练

然而在实际场景中，特征向量$\mathbf{x}$往往是高维且稀疏的（由于对cat型变量作one-hot编码），满足“$x_i$和$x_j$都非零”的样本将会非常少

训练样本的不足，很容易导致参数$w_{ij}$不准确，最终将严重影响模型的性能

【FM思想】

FM借鉴了协同过滤中将rating矩阵分解为user矩阵和item矩阵的方法

在本问题中，将矩阵$W$分解为两个相同的矩阵$V$，即$W=V^TV$，其中$V$是一个$n\times k$的矩阵，$k$是隐向量的维度，通常$k\ll n$，于是参数个数由$\frac{n(n-1)}{2}$个下降到$kn$个

【FM模型公式】

$\begin{aligned}y(\mathbf{x})=w_0+\sum\limits_{i=1}^{n}w_ix_i+\sum\limits_{i=1}^{n}\sum\limits_{j=i+1}^{n}\left \langle \mathbf{v}_i,\mathbf{v}_j \right \rangle x_ix_j\end{aligned}$
参数包括：$w_0$，$\begin{bmatrix}w_1\\ w_2\\ \vdots \\ w_n\end{bmatrix}$，$V_{n\times k}=\begin{bmatrix}-\mathbf{v}_1-\\ -\mathbf{v}_2-\\ \vdots\\ -\mathbf{v}_n-\end{bmatrix}=\begin{bmatrix}v_{1,1} & v_{1,2} & \cdots & v_{1,k}\\ v_{2,1} & v_{2,2} & \cdots & v_{2,k}\\ \vdots & \vdots & \ddots & \vdots \\ v_{n,1} & v_{n,2} & \cdots & v_{n,k}\end{bmatrix}$

【二次项化简】

$\begin{aligned}\sum\limits_{i=1}^{n}\sum\limits_{j=i+1}^{n}\left \langle \mathbf{v}_i,\mathbf{v}_j \right \rangle x_ix_j=\frac{1}{2}\sum\limits_{f=1}^{k}\left [ \left ( \sum\limits_{i=1}^{n}v_{i,f}\, x_i \right )^2-\sum\limits_{i=1}^{n}v_{i,f}^2\, x_i^2 \right ]\end{aligned}$

左式外层的二重求和复杂度为$O(n^2)$，内层计算向量点乘复杂度为$O(k)$，于是整个式子的复杂度为$O(kn^2)$

右式是一个二重求和，内外的复杂度分别为$O(n)$和$O(k)$，故整个式子的复杂度为$O(kn)$

综上所述，二次项经过化简，计算复杂度由$O(kn^2)$降为$O(kn)$

【二次项化简的推导】

假设$n=4$，$k=3$

(1) 展开左式的二重求和符号

(2) 展开向量点乘$\left \langle \mathbf{v}_i,\mathbf{v}_j \right \rangle$

(3) 按照分量$f=1, 2, 3$分类，拆分为$3$个子表

(4) 另一方面，构造如下式子，展开之后得到下表

(4) 将平方项减去之后乘上$1/2$

我们得到了(3)中完全相同的表，于是推导结束

【参数梯度】

为了便于说明，仍然假设$n=4$，$k=3$，对于某个$f$，有
$\begin{aligned} &\frac{1}{2}\left [ \left ( \sum\limits_{i=1}^{4}v_{i,f}\, x_i \right )^2-\sum\limits_{i=1}^{4}v_{i,f}^2\, x_i^2 \right ] \\&=\frac{1}{2}\left [ \left ( v_{1,f}\,x_1+v_{2,f}\,x_2+v_{3,f}\,x_3+v_{4,f}\,x_4 \right )^2 - \left ( v_{1,f}^2\,x_1^2+v_{2,f}^2\,x_2^2+v_{3,f}^2\,x_3^2+v_{4,f}^2\,x_4^2 \right ) \right ] \end{aligned}$

上式对$v_{i,f}$求导，得

$\begin{aligned}\frac{\partial y}{\partial v_{i,f}}&=\frac{1}{2}\left [ 2\left ( v_{1,f}\,x_1+v_{2,f}\,x_2+v_{3,f}\,x_3+v_{4,f}\,x_4 \right )x_i - 2v_{i,f}\,x_i^2 \right ] \\&=\left ( v_{1,f}\,x_1+v_{2,f}\,x_2+v_{3,f}\,x_3+v_{4,f}\,x_4 \right )x_i - v_{i,f}\,x_i^2 \\&=x_i\sum_{j=1}^{4}v_{j,f}\,x_j - v_{i,f}\,x_i^2\end{aligned}$

FM模型各个参数的梯度如下

$\begin{aligned}\frac{\partial y}{\partial \theta}=\left\{\begin{matrix}1 & \text{if $\theta$ is $w_0$} \\ x_i & \text{if $\theta$ is $w_i$} \\ x_i\sum\limits_{j=1}^{n}v_{j,f}\,x_j - v_{i,f}\,x_i^2 & \text{if $\theta$ is $v_{i,f}$} \end{matrix}\right.\end{aligned}$

对于某个$f$，$\begin{aligned}\sum\limits_{j=1}^{n}v_{j,f}\,x_j\end{aligned}$求完之后可以反复使用，求和的复杂度为$O(n)$，因此整个模型的训练复杂度为$O(kn)$

【FM模型缺点】
本质上为线性模型，没有考虑Field-aware

【loss function及梯度代码】

import numpy as np

seed = 0
np.random.seed( seed )



n, k, batch_size = 4, 3, 5

V = np.random.rand( n, k )
x = np.random.rand( n )
X = np.tile( x, (batch_size, 1) )

【非向量化实现，求1个样本x的loss，复杂度为$O(kn^2)$的计算方法】

loss = 0
for i in range(n):
    for j in range(i+1, n):
        v_i, v_j = V[i, :], V[j, :]
        loss += np.dot( v_i, v_j ) * x[i] * x[j]

print( 'loss =', loss )

【非向量化实现，求1个样本x的loss，复杂度为$O(kn)$的计算方法】

loss = 0
for f in range(k):

    term1, term2 = 0, 0

    for i in range(n):
        term1 += V[i, f] * x[i]
        term2 += V[i, f] ** 2 * x[i] ** 2

    loss += term1 ** 2 - term2

loss /= 2
print( 'loss =', loss )

【向量化实现，求batch_size个样本X的loss】

loss = 1/2 * np.sum( np.dot( X, V ) ** 2 - np.dot( X ** 2, V ** 2 ), axis=1 )
loss = np.mean( loss )
print( 'loss =', loss )

【非向量化实现，求1个样本x关于V的梯度，复杂度$O(kn)$】

grad_V = np.zeros_like(V)

for f in range(k):

    temp = 0
    for j in range(n):
        temp += V[j, f] * x[j]

    for i in range(n):
        grad_V[i, f] = x[i] * temp - V[i, f] * x[i]**2

print( grad_V )

【向量化实现，求1个样本x关于V的梯度，复杂度O(kn)】
temp = np.dot(x, V)
term1 = np.dot( np.expand_dims(x, axis=1), np.expand_dims(temp, axis=0) )

V * np.expand_dims(x**2, axis=1)使用了boardcast

V.shape=(n, k) np.expand_dims(x**2, axis=1).shape=(n, 1)

term2 = V * np.expand_dims(x**2, axis=1)

grad_V = term1 - term2
print( grad_V )

向量化实现，求batch_size个样本X关于V的梯度，复杂度O(kn)

term1 = np.dot( X.T, np.dot(X, V) )
term2 = V * np.dot( (X**2).T, np.ones( (batch_size, k) ) )
grad_V = term1 - term2
print( grad_V / batch_size )

梯度检查

def compute_loss( V, X ):
loss = 1/2 * np.sum( np.dot( X, V ) * 2 - np.dot( X * 2, V ** 2 ), axis=1 )
loss = np.mean( loss )
return loss

grad_V = np.zeros_like(V)
epsilon = 1e-4

for i in range( V.shape[0] ):
for j in range( V.shape[1] ):

    epsilon_vec = np.zeros_like(V)
    epsilon_vec[i, j] += epsilon

    grad_V[i, j] = ( compute_loss( V+epsilon_vec, X ) - compute_loss( V-epsilon_vec, X ) ) / ( 2 * epsilon )

print( grad_V )
【题外话】
A = np.random.rand(n, batch_size)

对一个矩阵按行求和，相当于右乘一个全为1的列向量

temp1 = np.sum( A, axis=1, keepdims=True )
temp2 = np.dot( A, np.ones( (batch_size, 1) ) )
print( temp1 )
print( temp2 )

对一个列向量做水平方向tile，相当于右乘一个全为1的行向量

temp1 = np.tile( temp1, (1, k) )
temp2 = np.dot( temp2, np.ones( (1, k) ) )
print( temp1 )
print( temp2 )

将上述两步合并起来，直接对矩阵右乘一个全为1的矩阵

temp = np.dot( A, np.ones( (batch_size, k) ) )
print( temp )