FM模型

大家好，又见面了，我是你们的朋友全栈君。

FM模型

一、FM模型的意义

1、传统模型的缺点

忽略了特征之间的联系
特征高维、稀疏，容易爆炸

2、什么是FM模型

FM就是Factor Machine，因子分解机。
FM通过对两两特征组合，引入交叉项特征，提高模型得分；其次是高维灾难，通过引入隐向量（对参数矩阵进行矩阵分解），完成对特征的参数估计。

二、FM模型

1、对特征进行组合

一般的线性模型
$y={\omega }_0+\sum _{i=1}^n{w}_i{x}_i$
二阶多项式模型
$y={\omega }_0+\sum _{i=1}^n{w}_i{x}_i+\sum _{i=1}^{n-1}\sum _{j=i+1}^n{\omega }_{ij}{x}_i{x}_j$
上式中，n表示样本的特征数量，xi表示第i个特征。
与线性模型相比，FM模型多了后面特征组合的部分。

2、FM求解

从上面的式子可以看到，组合部分的特征相关参数有$n\left(n-1\right)/2$个。但是对于稀疏数据来说，同时满足$x_i,x_j$都不为0的情况十分少，这就会导致${\omega }_{ij}$无法通过训练得到。
为了求出${\omega }_{ij}$，我们对每一个特征分量xi引入辅助向量$V_i=\left(v_{i1},v_{i2},\cdots ,v_{ik}\right)$。然后利用$v_i{v}_j^T$对${\omega }_{ij}$进行求解。

那么${\omega }_{ij}$组成的矩阵可以表示为：

求解$v_i$和$v_j$的具体过程如下：
$$\begin{array}{l}\sum _{i=1}^{n-1}\sum _{j=i+1}^n⟨{\nu }_i,{\nu }_j⟩x_i{x}_j\\ =\frac{1}{2}\sum _{i=1}^n\sum _{j=1}^n⟨{\nu }_i,{\nu }_j⟩x_i{x}_j-\frac{1}{2}\sum _{i=1}^n⟨{\nu }_i,{\nu }_i⟩x_i{x}_i\\ =\frac{1}{2}\left(\sum _{i=1}^n\sum _{j=1}^n\sum _{f=1}^k{v}_{i,f}{v}_{j,f}{x}_i{x}_j-\sum _{i=1}^n\sum _{f=1}^k{v}_{i,f}{v}_{j,f}{x}_i\right)\\ =\frac{1}{2}\sum _{f=1}^k\left(\left(\sum _{i=1}^n{v}_{i,f}{x}_i\right)\left(\sum _{j=1}^n{v}_{j,f}{x}_j\right)-\sum _{i=1}^n{v}_{i,f}^2{x}_i^2\right)\\ =\frac{1}{2}\sum _{f=1}^k\left({\left(\sum _{i=1}^n{v}_{i,f}{x}_i\right)}^2-\sum _{i=1}^n{v}_{i,f}^2{x}_i^2\right)\end{array}$$
梯度
FM有一个重要的性质：multilinearity：若$\Theta =\left({\omega }_0,{\omega }_1,{\omega }_2,\cdots ,{\omega }_n,v_{11},v_{12},\cdots ,v_{nk}\right)$表示FM模型的所有参数，则对于任意的$\theta \in \Theta$,存在与$\theta$无关的$g\left(x\right)$与$h\left(x\right)$,则二阶多项式模型可以表示为：
$$f\left(x\right)=g\left(x\right)+\theta h\left(x\right)$$
从上式可以看到，如果我们得到了$g\left(x\right)$与$h\left(x\right)$，则对于参数$\theta$的梯度为$h\left(x\right)$。

• 当$\theta ={\omega }_0$时，则：
  $$f\left(x\right)=\sum _{i=1}^n{\omega }_i{x}_i+\sum _{i=1}^{n-1}\sum _{j=i+1}^n\left(V_i^T{V}_j\right)x_i{x}_j+{\omega }_0\times 1$$
  最后一项1为$h\left(x\right)$，其余项为$g\left(x\right)$。可以看出此时的梯度为1。
• 当$\theta ={\omega }_l,l\in \left(1,2,\cdots ,n\right)$时，
  $$f\left(x\right)={\omega }_0+\sum _{i=1}^n{\omega }_i{x}_i+\sum _{i=1}^{n-1}\sum _{j=i+1}^n\left(V_i^T{V}_j\right)x_i{x}_j+{\omega }_l\times x_l$$
  此时梯度为$x_l$
• $\theta =v_{lm}$时
  $$f\left(x\right)={\omega }_0+\sum _{i=1}^n{\omega }_i{x}_i+\sum _{i=1}^{n-1}\sum _{j=i+1}^n\left(\sum _{s=1,is\ne lm,js\ne lm}^k{v}_{is}{v}_{js}\right)x_i{x}_j+v_{lm}\times x_l\sum _{i\ne l}{v}_{im}{x}_i$$
  此时梯度为$x_l\sum _{i\ne l}{v}_{im}{x}_i$。
  综上，$f\left(x\right)$关于$\theta$的偏导数为：
  
  更详细的推导过程请看文章。

三、FM代码

1、数据集

本文使用的数据集为MovieLens100k Datase，数据包括四列，分别是用户ID，电影ID，打分，时间戳。

2、数据处理

要使用FM模型，我们首先要将数据处理成一个矩阵，矩阵的大小是用户数 * 电影数。使用的是scipy.sparse中的csr.csr_matrix实现这个矩阵。
函数形式如下csr_matrix((data, indices, indptr)

可以看到，函数接收三个参数，
第一个参数是数值（也就是图中的values）
第二个参数是每个数对应的列号（也就是图中的column indices）
第三个参数是每行的起始的偏移量（也就是图中的row offsets）
图中的例子，row offsets的前rows个元素代表每一行的第一个非零元素在values中的位置。第一行的第一个非零元素在values的位置为0，也就是1，第二行的第一个非零元素在values的位置为2，也就是2，以此类推。因此第一行有两个非零元素1,7，他们在行中的位置对应为column indices的0,1。
数据处理的代码

def vectorize_dic(dic,ix=None,p=None,n=0,g=0):
    ''' :params:dic,特征列表字典，关键字是特征名 :params:ix,索引 :params:p,特征向量的维度 '''
    if ix == None:
        ix = dict()
    nz = n * g
    col_ix = np.empty(nz,dtype = int)#随机生成一个大小为nz的数组，元素为整数
    i = 0
    #dict.get(k,d),dict[k] if dict[k] else d
    for k,lis in dic.items():
        #users和users的list，或者是items和items的list
        for t in range(len(lis)):
            #为编号为t的user或者item赋值
            ix[str(lis[t]) + str(k)] = ix.get(str(lis[t]) + str(k),0) + 1
            col_ix[i + t * g] = ix[str(lis[t]) + str(k)]
        i += 1
    row_ix = np.repeat(np.arange(0,n),g)#np.repeat(np.arange(0,3),2):[0 0 1 1 2 2]
    data = np.zeros(nz)
    if p == None:
        p = len(ix)
    ixx = np.where(col_ix < p)
    return csr.csr_matrix((data[ixx],(row_ix[ixx],col_ix[ixx])),shape=(n,p)),ix

分批次训练模型

def batcher(X_,y_=None,batch_size=-1):
    n_samples = X_.shape[0]
    if batch_size == -1:
        batch_size = n_samples
    if batch_size < 1:
        raise ValueError("参数batch_size={}是不支持的".format(batch_size))
    for i in range(0,n_samples,batch_size):
        upper_bound = min(i + batch_size,n_samples)
        ret_x = X_[i:upper_bound]
        ret_y = None
        if y_ is not None:
            ret_y = y_[i:i + batch_size]
            yield (ret_x,ret_y) 

构建模型

x = tf.placeholder('float',[None,p])
y = tf.placeholder('float',[None,1])
w0 = tf.Variable(tf.zeros([1]))
w = tf.Variable(tf.zeros([p]))
v = tf.Variable(tf.random_normal([k,p],mean=0,stddev=0.01))
linear_terms = tf.add(w0,tf.reduce_sum(tf.multiply(w,x),1,keep_dims=True))
pair_interactions = 0.5 * tf.reduce_sum(tf.subtract(
    tf.pow(tf.matmul(x,tf.transpose(v)),2),
    tf.matmul(tf.pow(x,2),tf.transpose(tf.pow(v,2)))
),axis=1,keep_dims=True)
y_hat = tf.add(linear_terms,pair_interactions)
lambda_w = tf.constant(0.001,name='lambda_w')
lambda_v = tf.constant(0.001,name='lambda_v')
l2_norm = tf.reduce_sum(tf.add(
    tf.multiply(lambda_w,tf.pow(w,2)),
    tf.multiply(lambda_v,tf.pow(v,2))
))
error = tf.reduce_mean(tf.square(y - y_hat))
loss = tf.add(error,l2_norm)
train_op = tf.train.GradientDescentOptimizer(learning_rate=0.01).minimize(loss)