推荐系统遇上深度学习(七)--NFM模型理论和实践

梦里梦外; 2022-03-11 12:28 76阅读 0赞

预计阅读时间10分钟。

**引言**

在CTR预估中，为了解决稀疏特征的问题，学者们提出了FM模型来建模特征之间的交互关系。但是FM模型只能表达特征之间两两组合之间的关系，无法建模两个特征之间深层次的关系或者说多个特征之间的交互关系，因此学者们通过Deep Network来建模更高阶的特征之间的关系。

因此 FM和深度网络DNN的结合也就成为了CTR预估问题中主流的方法。有关FM和DNN的结合有两种主流的方法，并行结构和串行结构。两种结构的理解以及实现如下表所示：

![640?wx\_fmt=jpeg][640_wx_fmt_jpeg]

今天介绍的NFM模型(Neural Factorization Machine)，便是串行结构中一种较为简单的网络模型。

#  #

**NFM模型介绍**

我们首先来回顾一下FM模型，FM模型用n个隐变量来刻画特征之间的交互关系。这里要强调的一点是，n是特征的总数，是one-hot展开之后的，比如有三组特征，两个连续特征，一个离散特征有5个取值，那么n=7而不是n=3.

![640?wx\_fmt=jpeg][640_wx_fmt_jpeg 1]

顺便回顾一下化简过程：

![640?wx\_fmt=png][640_wx_fmt_png]

可以看到，不考虑最外层的求和，我们可以得到一个K维的向量。

对于NFM模型，目标值的预测公式变为：

其中，f(x)是用来建模特征之间交互关系的多层前馈神经网络模块，架构图如下所示：

![640?wx\_fmt=jpeg][640_wx_fmt_jpeg 2]

Embedding Layer和我们之间几个网络是一样的，embedding 得到的vector其实就是我们在FM中要学习的隐变量v。

Bi-Interaction Layer名字挺高大上的，其实它就是计算FM中的二次项的过程，因此得到的向量维度就是我们的Embedding的维度。最终的结果是：

![640?wx\_fmt=jpeg][640_wx_fmt_jpeg 3]

Hidden Layers就是我们的DNN部分，将Bi-Interaction Layer得到的结果接入多层的神经网络进行训练，从而捕捉到特征之间复杂的非线性关系。

在进行多层训练之后，将最后一层的输出求和同时加上一次项和偏置项，就得到了我们的预测输出：

![640?wx\_fmt=jpeg][640_wx_fmt_jpeg 4]

是不是很简单呢，哈哈。

#  #

**代码实战**

终于到了激动人心的代码实战环节了，本文的代码有不对的的地方或者改进之处还望大家多多指正。

本文的github地址为：  
https://github.com/princewen/tensorflow\_practice/tree/master/recommendation/Basic-NFM-Demo

本文的代码根据之前DeepFM的代码进行改进，我们只介绍模型的实现部分，其他数据处理的细节大家可以参考我的github上的代码.

模型输入

模型的输入主要有下面几个部分:

self.feat_index = tf.placeholder(tf.int32,
                             shape=[None,None],
                             name='feat_index')
    self.feat_value = tf.placeholder(tf.float32,
                           shape=[None,None],
                           name='feat_value')
    
    self.label = tf.placeholder(tf.float32,shape=[None,1],name='label')
    self.dropout_keep_deep = tf.placeholder(tf.float32,shape=[None],name='dropout_deep_deep')

feat\_index是特征的一个序号，主要用于通过embedding\_lookup选择我们的embedding。feat\_value是对应的特征值，如果是离散特征的话，就是1，如果不是离散特征的话，就保留原来的特征值。label是实际值。还定义了dropout来防止过拟合。

权重构建

权重主要分以下几部分，偏置项，一次项权重，embeddings，以及DNN的权重

def _initialize_weights(self):
    weights = dict()
    
    #embeddings
    weights['feature_embeddings'] = tf.Variable(
    tf.random_normal([self.feature_size,self.embedding_size],0.0,0.01),
    name='feature_embeddings')
    weights['feature_bias'] = tf.Variable(tf.random_normal([self.feature_size,1],0.0,1.0),name='feature_bias')
    weights['bias'] = tf.Variable(tf.constant(0.1),name='bias')
    
    #deep layers
    num_layer = len(self.deep_layers)
    input_size = self.embedding_size
    glorot = np.sqrt(2.0/(input_size + self.deep_layers[0]))
    
    weights['layer_0'] = tf.Variable(
    np.random.normal(loc=0,scale=glorot,size=(input_size,self.deep_layers[0])),dtype=np.float32
    )
    weights['bias_0'] = tf.Variable(
    np.random.normal(loc=0,scale=glorot,size=(1,self.deep_layers[0])),dtype=np.float32
    )
    
    
    for i in range(1,num_layer):
    glorot = np.sqrt(2.0 / (self.deep_layers[i - 1] + self.deep_layers[i]))
    weights["layer_%d" % i] = tf.Variable(
        np.random.normal(loc=0, scale=glorot, size=(self.deep_layers[i - 1], self.deep_layers[i])),
        dtype=np.float32)  # layers[i-1] * layers[i]
    weights["bias_%d" % i] = tf.Variable(
        np.random.normal(loc=0, scale=glorot, size=(1, self.deep_layers[i])),
        dtype=np.float32)  # 1 * layer[i]
    
    return weights

Embedding Layer  
这个部分很简单啦，是根据feat\_index选择对应的weights\['feature\_embeddings'\]中的embedding值，然后再与对应的feat\_value相乘就可以了：

# Embeddings
    self.embeddings = tf.nn.embedding_lookup(self.weights['feature_embeddings'],self.feat_index) # N * F * K
    feat_value = tf.reshape(self.feat_value,shape=[-1,self.field_size,1])
    self.embeddings = tf.multiply(self.embeddings,feat_value) # N * F * K

Bi-Interaction Layer  
我们直接根据化简后的结果进行计算，得到一个K维的向量：

# sum-square-part
    self.summed_features_emb = tf.reduce_sum(self.embeddings, 1)  # None * k
    self.summed_features_emb_square = tf.square(self.summed_features_emb)  # None * K
    
    # squre-sum-part
    self.squared_features_emb = tf.square(self.embeddings)
    self.squared_sum_features_emb = tf.reduce_sum(self.squared_features_emb, 1)  # None * K
    
    # second order
    self.y_second_order = 0.5 * tf.subtract(self.summed_features_emb_square, self.squared_sum_features_emb)

Deep Part  
将Bi-Interaction Layer层得到的结果经过一个多层的神经网络，得到交互项的输出：

self.y_deep = self.y_second_order
    for i in range(0, len(self.deep_layers)):
    self.y_deep = tf.add(tf.matmul(self.y_deep, self.weights["layer_%d" % i]), self.weights["bias_%d" % i])
    self.y_deep = self.deep_layers_activation(self.y_deep)
    self.y_deep = tf.nn.dropout(self.y_deep,    self.dropout_keep_deep[i + 1])

得到预测输出  
为了得到预测输出，我们还需要两部分，分别是偏置项和一次项：

# first order term
    self.y_first_order = tf.nn.embedding_lookup(self.weights['feature_bias'], self.feat_index)
    self.y_first_order = tf.reduce_sum(tf.multiply(self.y_first_order, feat_value), 2)
    
    # bias
    self.y_bias = self.weights['bias'] * tf.ones_like(self.label)

而我们的最终输出如下：

# out
    self.out = tf.add_n([tf.reduce_sum(self.y_first_order,axis=1,keep_dims=True),
                 tf.reduce_sum(self.y_deep,axis=1,keep_dims=True),
                 self.y_bias])

剩下的代码就不介绍啦！  
好啦，本文只是提供一个引子，有关NFM的知识大家可以更多的进行学习呦。

#  #

**小结**

NFM模型将FM与神经网络结合以提升FM捕捉特征间多阶交互信息的能力。根据论文中实验结果，NFM的预测准确度相较FM有明显提升，并且与现有的并行神经网络模型相比，复杂度更低。

NFM本质上还是基于FM，FM会让一个特征固定一个特定的向量，当这个特征与其他特征做交叉时，都是用同样的向量去做计算。这个是很不合理的，因为不同的特征之间的交叉，重要程度是不一样的。因此，学者们提出了AFM模型（Attentional factorization machines），将attention机制加入到我们的模型中，关于AFM的知识，我们下一篇来一探究竟。

原文链接：https://mp.weixin.qq.com/s/4hOHyDN-fDVXi3KV8UX2Cw

> 查阅更为简洁方便的分类文章以及最新的课程、产品信息，请移步至全新呈现的“LeadAI学院官网”：
> 
> www.leadai.org

请关注人工智能LeadAI公众号，查看更多专业文章

![640?wx\_fmt=jpeg][640_wx_fmt_jpeg 5]

大家都在看

![640.png?][640.png]

[LSTM模型在问答系统中的应用][LSTM]

[基于TensorFlow的神经网络解决用户流失概览问题][TensorFlow]

[最全常见算法工程师面试题目整理（一）][Link 1]

[最全常见算法工程师面试题目整理（二）][Link 2]

[TensorFlow从1到2 | 第三章 深度学习革命的开端：卷积神经网络][TensorFlow_1_2 _ _]

[装饰器 | Python高级编程][_ Python]

[今天不如来复习下Python基础][Python]

[640_wx_fmt_jpeg]: /images/20220311/074076c05233432d863ba85e3d408a53.png
[640_wx_fmt_jpeg 1]: /images/20220311/d3777d46cf874d5fb14f65f9011d23f8.png
[640_wx_fmt_png]: /images/20220311/00b5e69fea71409b88fdb8930d21bdfe.png
[640_wx_fmt_jpeg 2]: /images/20220311/7abf047ac85d48fc8702c404231dc6fc.png
[640_wx_fmt_jpeg 3]: /images/20220311/c2d72ce0aa924a68a833d65bc42a6611.png
[640_wx_fmt_jpeg 4]: /images/20220311/6942e713f0804247990e6a928e011502.png
[640_wx_fmt_jpeg 5]: /images/20220311/38193f7c2a4f4bb9ad9647b9bfee08ea.png
[640.png]: /images/20220311/31dbb5fcc8bd4ad28b8848e874a0cd21.png
[LSTM]: http://mp.weixin.qq.com/s?__biz=MzI2OTc5NTUwNg==&mid=2247484578&idx=3&sn=38654576f40c7c086fbe32d2b12c9862&chksm=eadbad7fddac246979cf49802a01c3136b1b0f79e6bfb3e9ace2172cfff4ed63be89f23b0f64&scene=21#wechat_redirect
[TensorFlow]: http://mp.weixin.qq.com/s?__biz=MzI2OTc5NTUwNg==&mid=2247484570&idx=4&sn=d22e41ff43460c040aae136b78f5c807&chksm=eadbad47ddac2451057b1c6975191f1044988fe9612e1fc248852fe2490052dd791c42770d96&scene=21#wechat_redirect
[Link 1]: http://mp.weixin.qq.com/s?__biz=MzI2OTc5NTUwNg==&mid=2247484530&idx=1&sn=462931eb9fd0dd1ac41f2e3f987fa51c&chksm=eadbadafddac24b91389d1bcea23be2668a0efbd425150e836d1ee5ba6d182b0a2f3cf6000dc&scene=21#wechat_redirect
[Link 2]: http://mp.weixin.qq.com/s?__biz=MzI2OTc5NTUwNg==&mid=2247484551&idx=3&sn=a481218ee3f5f4d766a48dca5f8c4c61&chksm=eadbad5addac244c9a9516376add6168ff1a415ba26994ede28c1613dfcc54222959c56a365f&scene=21#wechat_redirect
[TensorFlow_1_2 _ _]: http://mp.weixin.qq.com/s?__biz=MzI2OTc5NTUwNg==&mid=2247484516&idx=1&sn=40e8928353dbc29f17c8e22cd27944f4&chksm=eadbadb9ddac24af5943085537922db2f982f088f34ce20262eea314dbf5741dcefbc4a74404&scene=21#wechat_redirect
[_ Python]: http://mp.weixin.qq.com/s?__biz=MzI2OTc5NTUwNg==&mid=2247484476&idx=1&sn=503166979eeff5c974de3e3ce0d4b12e&chksm=eadbade1ddac24f70b22b22cb81a070fdab2e4dafc02c596eb3aa5acba83a9d1051e122258e2&scene=21#wechat_redirect
[Python]: http://mp.weixin.qq.com/s?__biz=MzI2OTc5NTUwNg==&mid=2247484452&idx=1&sn=c1cf5f55330a5ef89f0bce7faeda4c98&chksm=eadbadf9ddac24ef6e87ee35cc017d42a9ade6e47522b8a041a4b01227161bb17ce6102eafe0&scene=21#wechat_redirect