本文共 16804 字，大约阅读时间需要 56 分钟。
推荐系统遇上深度学习(一)--FM模型理论和实践
1、FM背景
在计算广告和推荐系统中，CTR预估(click-through rate)是非常重要的一个环节，判断一个商品的是否进行推荐需要根据CTR预估的点击率来进行。在进行CTR预估时，除了单特征外，往往要对特征进行组合。对于特征组合来说，业界现在通用的做法主要有两大类：FM系列与Tree系列。今天，我们就来讲讲FM算法。
2、one-hot编码带来的问题
FM(Factorization Machine)主要是为了解决数据稀疏的情况下，特征怎样组合的问题。已一个广告分类的问题为例，根据用户与广告位的一些特征，来预测用户是否会点击广告。数据如下：(本例来自美团技术团队分享的paper)
clicked是分类值，表明用户有没有点击该广告。1表示点击，0表示未点击。而country,day,ad_type则是对应的特征。对于这种categorical特征，一般都是进行one-hot编码处理。
将上面的数据进行one-hot编码以后，就变成了下面这样 ：
因为是categorical特征，所以经过one-hot编码以后，不可避免的样本的数据就变得很稀疏。举个非常简单的例子，假设淘宝或者京东上的item为100万，如果对item这个维度进行one-hot编码，光这一个维度数据的稀疏度就是百万分之一。由此可见，数据的稀疏性，是我们在实际应用场景中面临的一个非常常见的挑战与问题。
one-hot编码带来的另一个问题是特征空间变大。同样以上面淘宝上的item为例，将item进行one-hot编码以后，样本空间有一个categorical变为了百万维的数值特征，特征空间一下子暴增一百万。所以大厂动不动上亿维度，就是这么来的。
3、对特征进行组合
普通的线性模型，我们都是将各个特征独立考虑的，并没有考虑到特征与特征之间的相互关系。但实际上，大量的特征之间是有关联的。最简单的以电商为例，一般女性用户看化妆品服装之类的广告比较多，而男性更青睐各种球类装备。那很明显，女性这个特征与化妆品类服装类商品有很大的关联性，男性这个特征与球类装备的关联性更为密切。如果我们能将这些有关联的特征找出来，显然是很有意义的。
一般的线性模型为：
从上面的式子很容易看出，一般的线性模型压根没有考虑特征间的关联。为了表述特征间的相关性，我们采用多项式模型。在多项式模型中，特征xi与xj的组合用xixj表示。为了简单起见，我们讨论二阶多项式模型。具体的模型表达式如下：
上式中，n表示样本的特征数量,xi表示第i个特征。
与线性模型相比，FM的模型就多了后面特征组合的部分。4、FM求解
从上面的式子可以很容易看出，组合部分的特征相关参数共有n(n−1)/2个。但是如第二部分所分析，在数据很稀疏的情况下，满足xi,xj都不为0的情况非常少，这样将导致ωij无法通过训练得出。
为了求出ωij，我们对每一个特征分量xi引入辅助向量Vi=(vi1,vi2,⋯,vik)。然后，利用vivj^T对ωij进行求解。
那么ωij组成的矩阵可以表示为:
那么，如何求解vi和vj呢？主要采用了公式：
具体过程如下：
上面的式子中有同学曾经问我第一步是怎么推导的，其实也不难，看下面的手写过程(大伙可不要嫌弃字丑哟)
经过这样的分解之后，我们就可以通过随机梯度下降SGD进行求解：
5、tensorflow代码详解
代码参考地址：
上面的代码使用的是python2编码，在python3下运行会出错，所以如果大家使用的是python3的话，可以参考我写的，其实就是修复了几个bug啦，哈哈。我的github地址：。本文使用的数据是，数据包括四列，分别是用户ID，电影ID，打分，时间。
输入变换
要使用FM模型，我们首先要将数据处理成一个矩阵，矩阵的大小是用户数 * 电影数。如何根据现有的数据进行处理呢？使用的是scipy.sparse中的csr.csr_matrix，理解这个函数真的费了不少功夫呢，不过还是在下面博客()的帮助下理解了函数的原理。盗用博客中的一张图来帮助大家理解这个函数的输入：
函数形式如下：
csr_matrix((data, indices, indptr)
可以看到，函数接收三个参数，第一个参数是数值，第二个参数是每个数对应的列号，第三个参数是每行的起始的偏移量，举上图的例子来说，第0行的起始偏移是0，第0行有2个非0值，因此第一行的起始偏移是2，第1行有两个非0值，因此第二行的起始偏移是4，依次类推。
下面的代码是如何将原始的文件输入转换成我们的矩阵：
def vectorize_dic(dic,ix=None,p=None,n=0,g=0): """ dic -- dictionary of feature lists. Keys are the name of features ix -- index generator (default None) p -- dimension of featrure space (number of columns in the sparse matrix) (default None) """ if ix==None: ix = dict() nz = n * g col_ix = np.empty(nz,dtype = int) i = 0 for k,lis in dic.items(): for t in range(len(lis)): 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) data = np.ones(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)),ixcols = ['user','item','rating','timestamp']train = pd.read_csv('data/ua.base',delimiter='\t',names = cols)test = pd.read_csv('data/ua.test',delimiter='\t',names = cols)x_train,ix = vectorize_dic({'users':train['user'].values, 'items':train['item'].values},n=len(train.index),g=2)x_test,ix = vectorize_dic({'users':test['user'].values, 'items':test['item'].values},ix,x_train.shape[1],n=len(test.index),g=2)y_train = train['rating'].valuesy_test = test['rating'].valuesx_train = x_train.todense()x_test = x_test.todense() 如果不做处理，函数返回的矩阵是按如下的格式保存的：
使用todense变换后，变成如下样式：
估计值计算
得到我们的输入之后，我们使用tensorflow来设计我们的模型，其实很简单啦，我们模型的估计值由两部分构成，原始的可以理解为线性回归的部分，以及交叉特征的部分，交叉特征直接使用我们最后推导的形式即可，再回顾一遍：因此，我们需要定义三个placeholder，分别是输入的x，输入的y，以及我们的 用户数*电影数大小的待学习的fm矩阵：
n,p = x_train.shapek = 10x = 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))#y_hat = tf.Variable(tf.zeros([n,1]))linear_terms = tf.add(w0,tf.reduce_sum(tf.multiply(w,x),1,keep_dims=True)) # n * 1pair_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) 定义损失函数
这里我们定义的损失函数除了平方损失外，还加了l2正则项，并使用梯度下降法进行参数的更新：
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)
模型训练
接下来就是训练啦，这段代码比较好理解：epochs = 10batch_size = 1000# Launch the graphinit = tf.global_variables_initializer()with tf.Session() as sess: sess.run(init) for epoch in tqdm(range(epochs), unit='epoch'): perm = np.random.permutation(x_train.shape[0]) # iterate over batches for bX, bY in batcher(x_train[perm], y_train[perm], batch_size): _,t = sess.run([train_op,loss], feed_dict={x: bX.reshape(-1, p), y: bY.reshape(-1, 1)}) print(t) errors = [] for bX, bY in batcher(x_test, y_test): errors.append(sess.run(error, feed_dict={x: bX.reshape(-1, p), y: bY.reshape(-1, 1)})) print(errors) RMSE = np.sqrt(np.array(errors).mean()) print (RMSE) 参考文章：
1、
2、推荐系统遇上深度学习(二)--FFM模型理论和实践
1、FFM理论
在CTR预估中，经常会遇到one-hot类型的变量，one-hot类型变量会导致严重的数据特征稀疏的情况，为了解决这一问题，在上一讲中，我们介绍了FM算法。这一讲我们介绍一种在FM基础上发展出来的算法-FFM（Field-aware Factorization Machine）。
FFM模型中引入了类别的概念，即field。还是拿上一讲中的数据来讲，先看下图：
在上面的广告点击案例中，“Day=26/11/15”、“Day=1/7/14”、“Day=19/2/15”这三个特征都是代表日期的，可以放到同一个field中。同理，Country也可以放到一个field中。简单来说，同一个categorical特征经过One-Hot编码生成的数值特征都可以放到同一个field，包括用户国籍，广告类型，日期等等。
在FFM中，每一维特征 xi，针对其它特征的每一种field fj，都会学习一个隐向量 v_i,fj。因此，隐向量不仅与特征相关，也与field相关。也就是说，“Day=26/11/15”这个特征与“Country”特征和“Ad_type"特征进行关联的时候使用不同的隐向量，这与“Country”和“Ad_type”的内在差异相符，也是FFM中“field-aware”的由来。
假设样本的 n个特征属于 f个field，那么FFM的二次项有 nf个隐向量。而在FM模型中，每一维特征的隐向量只有一个。FM可以看作FFM的特例，是把所有特征都归属到一个field时的FFM模型。根据FFM的field敏感特性，可以导出其模型方程。
可以看到，如果隐向量的长度为 k，那么FFM的二次参数有 nfk 个，远多于FM模型的 nk个。此外，由于隐向量与field相关，FFM二次项并不能够化简，其预测复杂度是 O(kn^2)。
下面以一个例子简单说明FFM的特征组合方式。输入记录如下：
这条记录可以编码成5个特征，其中“Genre=Comedy”和“Genre=Drama”属于同一个field，“Price”是数值型，不用One-Hot编码转换。为了方便说明FFM的样本格式，我们将所有的特征和对应的field映射成整数编号。
那么，FFM的组合特征有10项，如下图所示。
其中，红色是field编号，蓝色是特征编号。
2、FFM实现细节
这里讲得只是一种FFM的实现方式，并不是唯一的。
损失函数
FFM将问题定义为分类问题，使用的是logistic loss，同时加入了正则项什么，这是logisitc loss？第一眼看到我是懵逼的，逻辑回归的损失函数我很熟悉啊，不是长这样的啊？其实是我目光太短浅了。逻辑回归其实是有两种表述方式的损失函数的，取决于你将类别定义为0和1还是1和-1。大家可以参考下下面的文章：。当我们将类别设定为1和-1的时候，逻辑回归的损失函数就是上面的样子。
随机梯度下降
训练FFM使用的是随机梯度下降方法，即每次只选一条数据进行训练，这里还有必要补一补梯度下降的知识，梯度下降是有三种方式的，截图取自参考文献3：
总给人一种怪怪的感觉。batch为什么是全量的数据呢，哈哈。
3、tensorflow实现代码
本文代码的github地址：
这里我们只讲解一些细节，具体的代码大家可以去github上看：
生成数据
这里我没有找到合适的数据，就自己产生了一点数据，数据涉及20维特征，前十维特征是一个field，后十维是一个field:def gen_data(): labels = [-1,1] y = [np.random.choice(labels,1)[0] for _ in range(all_data_size)] x_field = [i // 10 for i in range(input_x_size)] x = np.random.randint(0,2,size=(all_data_size,input_x_size)) return x,y,x_field
定义权重项
在ffm中，有三个权重项，首先是bias，然后是一维特征的权重，最后是交叉特征的权重：def createTwoDimensionWeight(input_x_size,field_size,vector_dimension): weights = tf.truncated_normal([input_x_size,field_size,vector_dimension]) tf_weights = tf.Variable(weights) return tf_weightsdef createOneDimensionWeight(input_x_size): weights = tf.truncated_normal([input_x_size]) tf_weights = tf.Variable(weights) return tf_weightsdef createZeroDimensionWeight(): weights = tf.truncated_normal([1]) tf_weights = tf.Variable(weights) return tf_weights
计算估计值
估计值的计算这里不能项FM一样先将公式化简再来做，对于交叉特征，只能写两重循环，所以对于特别多的特征的情况下，真的计算要爆炸呀！def inference(input_x,input_x_field,zeroWeights,oneDimWeights,thirdWeight): """计算回归模型输出的值""" secondValue = tf.reduce_sum(tf.multiply(oneDimWeights,input_x,name='secondValue')) firstTwoValue = tf.add(zeroWeights, secondValue, name="firstTwoValue") thirdValue = tf.Variable(0.0,dtype=tf.float32) input_shape = input_x_size for i in range(input_shape): featureIndex1 = I fieldIndex1 = int(input_x_field[I]) for j in range(i+1,input_shape): featureIndex2 = j fieldIndex2 = int(input_x_field[j]) vectorLeft = tf.convert_to_tensor([[featureIndex1,fieldIndex2,i] for i in range(vector_dimension)]) weightLeft = tf.gather_nd(thirdWeight,vectorLeft) weightLeftAfterCut = tf.squeeze(weightLeft) vectorRight = tf.convert_to_tensor([[featureIndex2,fieldIndex1,i] for i in range(vector_dimension)]) weightRight = tf.gather_nd(thirdWeight,vectorRight) weightRightAfterCut = tf.squeeze(weightRight) tempValue = tf.reduce_sum(tf.multiply(weightLeftAfterCut,weightRightAfterCut)) indices2 = [I] indices3 = [j] xi = tf.squeeze(tf.gather_nd(input_x, indices2)) xj = tf.squeeze(tf.gather_nd(input_x, indices3)) product = tf.reduce_sum(tf.multiply(xi, xj)) secondItemVal = tf.multiply(tempValue, product) tf.assign(thirdValue, tf.add(thirdValue, secondItemVal)) return tf.add(firstTwoValue,thirdValue)
定义损失函数
损失函数我们就用逻辑回归损失函数来算，同时加入正则项：lambda_w = tf.constant(0.001, name='lambda_w')lambda_v = tf.constant(0.001, name='lambda_v')zeroWeights = createZeroDimensionWeight()oneDimWeights = createOneDimensionWeight(input_x_size)thirdWeight = createTwoDimensionWeight(input_x_size, # 创建二次项的权重变量 field_size, vector_dimension) # n * f * ky_ = inference(input_x, trainx_field,zeroWeights,oneDimWeights,thirdWeight)l2_norm = tf.reduce_sum( tf.add( tf.multiply(lambda_w, tf.pow(oneDimWeights, 2)), tf.reduce_sum(tf.multiply(lambda_v, tf.pow(thirdWeight, 2)),axis=[1,2]) ))loss = tf.log(1 + tf.exp(input_y * y_)) + l2_normtrain_step = tf.train.GradientDescentOptimizer(learning_rate=lr).minimize(loss)
训练
接下来就是训练了，每次只用喂一个数据就好：input_x_batch = trainx[t]input_y_batch = trainy[t]predict_loss,_, steps = sess.run([loss,train_step, global_step], feed_dict={input_x: input_x_batch, input_y: input_y_batch}) 跑的是相当的慢，我们来看看效果吧：
参考文章
1、
2、3、推荐系统遇上深度学习(三)--DeepFM模型理论和实践
1、背景
特征组合的挑战
对于一个基于CTR预估的推荐系统，最重要的是学习到用户点击行为背后隐含的特征组合。在不同的推荐场景中，低阶组合特征或者高阶组合特征可能都会对最终的CTR产生影响。之前介绍的因子分解机(Factorization Machines, FM)通过对于每一维特征的隐变量内积来提取特征组合。最终的结果也非常好。但是，虽然理论上来讲FM可以对高阶特征组合进行建模，但实际上因为计算复杂度的原因一般都只用到了二阶特征组合。
那么对于高阶的特征组合来说，我们很自然的想法，通过多层的神经网络即DNN去解决。
DNN的局限
下面的图片来自于张俊林教授在AI大会上所使用的PPT。我们之前也介绍过了，对于离散特征的处理，我们使用的是将特征转换成为one-hot的形式，但是将One-hot类型的特征输入到DNN中，会导致网络参数太多：
如何解决这个问题呢，类似于FFM中的思想，将特征分为不同的field：
再加两层的全链接层，让Dense Vector进行组合，那么高阶特征的组合就出来了
但是低阶和高阶特征组合隐含地体现在隐藏层中，如果我们希望把低阶特征组合单独建模，然后融合高阶特征组合。
即将DNN与FM进行一个合理的融合：
二者的融合总的来说有两种形式，一是串行结构，二是并行结构
而我们今天要讲到的DeepFM，就是并行结构中的一种典型代表。
2、DeepFM模型
我们先来看一下DeepFM的模型结构：
DeepFM包含两部分：神经网络部分与因子分解机部分，分别负责低阶特征的提取和高阶特征的提取。这两部分共享同样的输入。DeepFM的预测结果可以写为：
FM部分
FM部分的详细结构如下：
FM部分是一个因子分解机。关于因子分解机可以参阅文章[Rendle, 2010] Steffen Rendle. Factorization machines. In ICDM, 2010.。因为引入了隐变量的原因，对于几乎不出现或者很少出现的隐变量，FM也可以很好的学习。
FM的输出公式为：
深度部分
深度部分是一个前馈神经网络。与图像或者语音这类输入不同，图像语音的输入一般是连续而且密集的，然而用于CTR的输入一般是及其稀疏的。因此需要重新设计网络结构。具体实现中为，在第一层隐含层之前，引入一个嵌入层来完成将输入向量压缩到低维稠密向量。
嵌入层(embedding layer)的结构如上图所示。当前网络结构有两个有趣的特性，1）尽管不同field的输入长度不同，但是embedding之后向量的长度均为K。2)在FM里得到的隐变量Vik现在作为了嵌入层网络的权重。
这里的第二点如何理解呢，假设我们的k=5，首先，对于输入的一条记录，同一个field 只有一个位置是1，那么在由输入得到dense vector的过程中，输入层只有一个神经元起作用，得到的dense vector其实就是输入层到embedding层该神经元相连的五条线的权重，即vi1，vi2，vi3，vi4，vi5。这五个值组合起来就是我们在FM中所提到的Vi。在FM部分和DNN部分，这一块是共享权重的，对同一个特征来说，得到的Vi是相同的。
有关模型具体如何操作，我们可以通过代码来进一步加深认识。
3、相关知识
我们先来讲两个代码中会用到的相关知识吧，代码是参考的github上星数最多的DeepFM实现代码。
Gini Normalization
代码中将CTR预估问题设定为一个二分类问题，绘制了Gini Normalization来评价不同模型的效果。这个是什么东西，不太懂，百度了很多，发现了一个比较通俗易懂的介绍。假设我们有下面两组结果，分别表示预测值和实际值：
predictions = [0.9, 0.3, 0.8, 0.75, 0.65, 0.6, 0.78, 0.7, 0.05, 0.4, 0.4, 0.05, 0.5, 0.1, 0.1]actual = [1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0]
然后我们将预测值按照从小到大排列，并根据索引序对实际值进行排序：
Sorted Actual Values [0, 0, 0, 0, 1, 0, 0, 0, 1, 1, 0, 1, 0, 1, 1]
然后，我们可以画出如下的图片：
接下来我们将数据Normalization到0，1之间。并画出45度线。
橙色区域的面积，就是我们得到的Normalization的Gini系数。
这里，由于我们是将预测概率从小到大排的，所以我们希望实际值中的0尽可能出现在前面，因此Normalization的Gini系数越大，分类效果越好。
embedding_lookup
在tensorflow中有个embedding_lookup函数，我们可以直接根据一个序号来得到一个词或者一个特征的embedding值，那么他内部其实是包含一个网络结构的，如下图所示：假设我们想要找到2的embedding值，这个值其实是输入层第二个神经元与embedding层连线的权重值。
之前有大佬跟我探讨word2vec输入的问题，现在也算是有个比较明确的答案，输入其实就是one-hot Embedding，而word2vec要学习的是new Embedding。
4、代码解析
好，一贯的风格，先来介绍几个地址：
原代码地址：本文代码地址：数据下载地址：好了，话不多说，我们来看看代码目录吧，接下来，我们将主要对网络的构建进行介绍，而对数据的处理，流程的控制部分，相信大家根据代码就可以看懂。
项目结构
项目结构如下：其实还应该有一个存放data的路径。config.py保存了我们模型的一些配置。DataReader对数据进行处理，得到模型可以使用的输入。DeepFM是我们构建的模型。main是项目的入口。metrics是计算normalized gini系数的代码。
模型输入
模型的输入主要有下面几个部分：
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_fm = tf.placeholder(tf.float32,shape=[None],name='dropout_keep_fm')self.dropout_keep_deep = tf.placeholder(tf.float32,shape=[None],name='dropout_deep_deep')
feat_index是特征的一个序号，主要用于通过embedding_lookup选择我们的embedding。feat_value是对应的特征值，如果是离散特征的话，就是1，如果不是离散特征的话，就保留原来的特征值。label是实际值。还定义了两个dropout来防止过拟合。
权重构建
权重的设定主要有两部分，第一部分是从输入到embedding中的权重，其实也就是我们的dense vector。另一部分就是深度神经网络每一层的权重。第二部分很好理解，我们主要来看看第一部分：#embeddingsweights['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['feature_embeddings'] 存放的每一个值其实就是FM中的vik，所以它是F * K的。其中，F代表feture的大小(将离散特征转换成one-hot之后的特征总量),K代表dense vector的大小。
weights['feature_bias']是FM中的一次项的权重。
Embedding part
这个部分很简单啦，是根据feat_index选择对应的weights['feature_embeddings']中的embedding值，然后再与对应的feat_value相乘就可以了：# modelself.embeddings = tf.nn.embedding_lookup(self.weights['feature_embeddings'],self.feat_index) # N * F * Kfeat_value = tf.reshape(self.feat_value,shape=[-1,self.field_size,1])self.embeddings = tf.multiply(self.embeddings,feat_value)
FM part
首先来回顾一下我们之前对FM的化简公式，之前去今日头条面试还问到过公式的推导。所以我们的二次项可以根据化简公式轻松的得到，再加上我们的一次项，FM的part就算完了。同时更为方便的是，由于权重共享，我们这里可以直接用Embedding part计算出的embeddings来得到我们的二次项：
# first order termself.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)self.y_first_order = tf.nn.dropout(self.y_first_order,self.dropout_keep_fm[0])# second order term# sum-square-partself.summed_features_emb = tf.reduce_sum(self.embeddings,1) # None * kself.summed_features_emb_square = tf.square(self.summed_features_emb) # None * K# squre-sum-partself.squared_features_emb = tf.square(self.embeddings)self.squared_sum_features_emb = tf.reduce_sum(self.squared_features_emb, 1) # None * K#second orderself.y_second_order = 0.5 * tf.subtract(self.summed_features_emb_square,self.squared_sum_features_emb)self.y_second_order = tf.nn.dropout(self.y_second_order,self.dropout_keep_fm[1])
DNN part
DNNpart的话，就是将Embedding part的输出再经过几层全链接层：# Deep componentself.y_deep = tf.reshape(self.embeddings,shape=[-1,self.field_size * self.embedding_size])self.y_deep = tf.nn.dropout(self.y_deep,self.dropout_keep_deep[0])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])
最后，我们要将DNN和FM两部分的输出进行结合：
concat_input = tf.concat([self.y_first_order, self.y_second_order, self.y_deep], axis=1)
损失及优化器
我们可以使用logloss(如果定义为分类问题)，或者mse(如果定义为预测问题)，以及多种的优化器去进行尝试，这些根据不同的参数设定得到：# lossif self.loss_type == "logloss": self.out = tf.nn.sigmoid(self.out) self.loss = tf.losses.log_loss(self.label, self.out)elif self.loss_type == "mse": self.loss = tf.nn.l2_loss(tf.subtract(self.label, self.out))# l2 regularization on weightsif self.l2_reg > 0: self.loss += tf.contrib.layers.l2_regularizer( self.l2_reg)(self.weights["concat_projection"]) if self.use_deep: for i in range(len(self.deep_layers)): self.loss += tf.contrib.layers.l2_regularizer( self.l2_reg)(self.weights["layer_%d" % I])if self.optimizer_type == "adam": self.optimizer = tf.train.AdamOptimizer(learning_rate=self.learning_rate, beta1=0.9, beta2=0.999, epsilon=1e-8).minimize(self.loss)elif self.optimizer_type == "adagrad": self.optimizer = tf.train.AdagradOptimizer(learning_rate=self.learning_rate, initial_accumulator_value=1e-8).minimize(self.loss)elif self.optimizer_type == "gd": self.optimizer = tf.train.GradientDescentOptimizer(learning_rate=self.learning_rate).minimize(self.loss)elif self.optimizer_type == "momentum": self.optimizer = tf.train.MomentumOptimizer(learning_rate=self.learning_rate, momentum=0.95).minimize( self.loss)
模型效果
前面提到了，我们用logloss作为损失函数去进行模型的参数更新，但是代码中输出了模型的 Normalization 的 Gini值来进行模型评价，我们可以对比一下(记住，Gini值越大越好呦)：好啦，本文只是提供一个引子，有关DeepFM更多的知识大家可以更多的进行学习呦。
参考资料
1、
2、转载地址：https://www.cnblogs.com/DjangoBlog/p/10749104.html 如侵犯您的版权，请留言回复原文章的地址，我们会给您删除此文章，给您带来不便请您谅解！
发表评论
最新留言
关于作者
