图神经网络用于推荐系统问题（NGCF，LightGCN）

何向南老师组的又两大必读论文，分别发在SIGIR19’和SIGIR20’。

Neural Graph Collaborative Filtering
协同过滤（collaborative filtering）的基本假设是相似的用户会对物品展现出相似的偏好，自从全面进入深度学习领域之后，一般主要是先在隐空间中学习关于user和item的embedding，然后重建两者的交互即interaction modeling，如MF做内积，NCF模拟高阶交互等。但是他们并没有把user和item的交互信息本身编码进 embedding 中，这就是NGCF想解决的点：显式建模User-Item 之间的高阶连接性来提升 embedding。

High-order Connectivity
解释高阶连通性如上图，图1左边为一般CF中user-item交互的二部图，双圆圈表示此时需要预测的用户u1，对于u1我们可以把有关他的连接扩展成右图的树形结构，l是能到达的路径长度（或者可以叫跳数），l=1表明能一步到达u1的item，此时可以看到最外层的跳数相同的i4跟i5相比（l都为3），用户u1对i4的兴趣可能要比i5高，因为i4->u2->i2->u1、i4->u3->i3->u1有两条路径，而i5->u2->i2->u1只有一条，所以i4的相似性会更高。所以如果能扩展成这样的路径连通性来解释用户的兴趣，就是高阶连通性。

NGCF的完整模型如下图，可以分为三个部分来看：

• Embeddings：对user和item的嵌入向量，普通的用id来嵌入就可以了
• Embedding Propagation Layers：挖掘高阶连通性关系来捕捉交互以细化Embedding的多个嵌入传播层
• Prediction Layer：用更新之后带有交互信息的 user 和 item Embedding来进行预测
  

主要就是中间的交互信息捕捉怎么构建，主要思路是借助GNN的message passing消息传递机制：$m_{u\leftarrow i}=\frac{1}{\sqrt {|N_u||N_i|}}(W_1e_i+W_2(e_i\odot e_u))$其中Mu←i是消息嵌入(即要传播的信息)，使用embedding后的user，item的特征$e_u,e_i$作为输入，然后两者计算内积相似度来控制邻域的信息，再加回到item上，用权重W控制权重，最后的N是u和i的度用来归一化系数，可以看做是折扣系数，随着传播路径长度的增大，信息慢慢衰减。

博主自己的理解是实际上做了一个小型的attention从领域的item整合信息，所以下一步就是用这些邻域信息更新user：$e^{(1)}_u=LeakyReLU(m_{u\leftarrow u}+\sum_{i\in N_u}m_{u\leftarrow i})$上标（1）表示一阶聚合，可以看到从领域的i中整合信息又考虑到了自身节点的信息，最后再激活一下。高阶传播实际就是将上述的一阶传播堆叠多层，这样经过 l 次聚合，每个节点都会融合其 l 阶邻居的信息，也就得到了节点的 l 阶表示，具体的传播如下图：
对应user u2来说，先由直接连接的i2，i4，i5开始是一阶，进行上述的聚合更新之后，聚合二阶邻居（此时u1也完成了更新），此时用u1和u2更新i2，同样的其他的item也会相应的更新，最后再由i1，i2，i3来更新u1，这样通过相互更新相互迭代，就完成了开篇那张图的树形结果。

如果把上述的更新换成矩阵形式的话：
$E^{(l)}=\sigma((L+I)E^{(l-1)}W^{(l)}_1+LE^{(l-1)}\odot E^{(l-1)}W^{(l)}_2)$其中$L=D^{-1/2}AD^{-1/2}$，这其实和GCN很像了。最后再将 L 阶的节点表示全部readout，分拼接起来作为最终的节点表示，再内积得到预测结果：$y'_{NGCF}(u,i)={e^*_u}^Te^*_i$损失函数就是常规的成对loss操作$Loss=\sum_{(u,i,j)\in O} -ln \sigma(y'_{ui}-y'_{uj})+\lambda||\Theta||^2$

最后再看看ngcf的关键代码：

def _create_ngcf_embed(self):
        # Generate a set of adjacency sub-matrix.
        # 使用矩阵的解法，所以先得到邻接矩阵
        if self.node_dropout_flag:
            # node dropout.
            A_fold_hat = self._split_A_hat_node_dropout(self.norm_adj)
        else:
            A_fold_hat = self._split_A_hat(self.norm_adj)
        #最初的嵌入形式
        ego_embeddings = tf.concat([self.weights['user_embedding'], self.weights['item_embedding']], axis=0)

        all_embeddings = [ego_embeddings]
        #执行k层的消息传播
        for k in range(0, self.n_layers):
            temp_embed = []
            for f in range(self.n_fold):
                temp_embed.append(tf.sparse_tensor_dense_matmul(A_fold_hat[f], ego_embeddings))

            # u到u，聚合u所有邻居的消息
            side_embeddings = tf.concat(temp_embed, 0)
            # 特征变换矩阵
            sum_embeddings = tf.nn.leaky_relu(
                tf.matmul(side_embeddings, self.weights['W_gc_%d' % k]) + self.weights['b_gc_%d' % k])

            # i到u，合并自嵌入，邻居的嵌入
            bi_embeddings = tf.multiply(ego_embeddings, side_embeddings)
            # 再次变换特征
            bi_embeddings = tf.nn.leaky_relu(
                tf.matmul(bi_embeddings, self.weights['W_bi_%d' % k]) + self.weights['b_bi_%d' % k])

            #非线性激活函数，u到u和i到u的两部分
            ego_embeddings = sum_embeddings + bi_embeddings

            # message dropout.
            ego_embeddings = tf.nn.dropout(ego_embeddings, 1 - self.mess_dropout[k])

            #正则化
            norm_embeddings = tf.math.l2_normalize(ego_embeddings, axis=1)

            all_embeddings += [norm_embeddings]

        all_embeddings = tf.concat(all_embeddings, 1)#拼一起
        u_g_embeddings, i_g_embeddings = tf.split(all_embeddings, [self.n_users, self.n_items], 0)
        return u_g_embeddings, i_g_embeddings

paper：https://arxiv.org/abs/1905.08108
code：https://github.com/xiangwang1223/neural_graph_collaborative_filtering

LightGCN: Simplifying and Powering Graph Convolution Network for Recommendation
前一篇的NGCF主要遵循标准GCN变形得到，包括使用非线性激活函数和特征变换矩阵w1和W2。然而作者认为实际上这两种操作对于CF并没什么大用，理由在于不管是user还是item，他们的输入都只是ID嵌入得到的，即根本没有具体的语义（一般在GCN的应用场景中每个节点会带有很多的其他属性），所以在这种情况下，执行多个非线性转换不会有助于学习更好的特性；更糟糕的是，它可能会增加训练的困难，降低推荐的结果。

所以将非线性激活函数non-linear和特征变换矩阵feature transformation都去掉，只增加一组权重系数来邻域聚集weighted aggregate不同gcn层输出的嵌入为最终的嵌入，大大简化了模型。即在LightGCN中，只采用简单的加权和聚合器，放弃了特征变换和非线性激活的使用，所以公式变为（只剩下）：
$e^{(k+1)}_u=\sum_{i\in N_u} \frac{1}{\sqrt{|N_u|}\sqrt{|N_i|}}e^{(k)}_i$$e^{(k+1)}_i=\sum_{u\in N_i} \frac{1}{\sqrt{|N_i|}\sqrt{|N_u|}}e^{(k)}_u$而且从上式可以看到它只聚合连接的邻居，连自连接都没有。最后的K层就直接组合在每个层上获得的嵌入，以形成用户（项）的最终表示：$e_u=\sum^K_{k=0} \alpha_k e^{(k)}_u$$e_i=\sum^K_{k=0} \alpha_k e^{(k)}_i$其中αk设置为1/（K+1）时效果最好。其余的部分就和NGCF一模一样。

为什么要组合所有层？

• GCN随着层数的增加会过平滑，直接用最后一层不合理
• 不同层的嵌入捕获不同的语义，而且更高层能捕获更高阶的信息，结合起来更加全面
• 将不同层的嵌入与加权和结合起来，可以捕获具有自连接的图卷积的效果，这是GCNs中的一个重要技巧

同样看一下关键部分的代码，代码量真的要简洁许多：

def _create_lightgcn_embed(self):
        if self.node_dropout_flag:
            A_fold_hat = self._split_A_hat_node_dropout(self.norm_adj)
        else:
            A_fold_hat = self._split_A_hat(self.norm_adj)
        
        ego_embeddings = tf.concat([self.weights['user_embedding'], self.weights['item_embedding']], axis=0)
        all_embeddings = [ego_embeddings]
        
        for k in range(0, self.n_layers):
            temp_embed = []
            for f in range(self.n_fold):
                temp_embed.append(tf.sparse_tensor_dense_matmul(A_fold_hat[f], ego_embeddings))
                
            #归一化已经在A里面得到A_hat了，所以这里直接聚合就完了
            side_embeddings = tf.concat(temp_embed, 0)
            ego_embeddings = side_embeddings
            all_embeddings += [ego_embeddings]
        all_embeddings=tf.stack(all_embeddings,1)#然后拼一起
        all_embeddings=tf.reduce_mean(all_embeddings,axis=1,keepdims=False)
        u_g_embeddings, i_g_embeddings = tf.split(all_embeddings, [self.n_users, self.n_items], 0)
        return u_g_embeddings, i_g_embeddings

paper：https://arxiv.org/abs/2002.02126
code：https://github.com/kuandeng/LightGCN

---

完整的关键代码中文注释可以参考：https://github.com/nakaizura/Source-Code-Notebook/