论文项目的主题框架如下：
1. 代码框架
1.1 GMF
代码是使用keras来实现的深度学习，其中GMF.py是传统的Matrix Factorization算法，关键代码分为两部分：
def get_model(num_users, num_items, latent_dim, regs=[0, 0]):
# Input variables
user_input = Input(shape=(1,), dtype='int32', name='user_input')
item_input = Input(shape=(1,), dtype='int32', name='item_input')
# MF_Embedding_User = Embedding(input_dim = num_users, output_dim = latent_dim, name = 'user_embedding',
# init = init_normal, W_regularizer = l2(regs[0]), input_length=1)
MF_Embedding_User = Embedding(input_dim=num_users, output_dim=latent_dim,
embeddings_initializer=initializers.random_normal(),
embeddings_regularizer=l2(regs[0]), input_length=1, name='user_embedding')
# MF_Embedding_Item = Embedding(input_dim = num_items, output_dim = latent_dim, name = 'item_embedding',
# init = init_normal, W_regularizer = l2(regs[1]), input_length=1)
MF_Embedding_Item = Embedding(input_dim=num_items, output_dim=latent_dim,
embeddings_initializer=initializers.random_normal(),
embeddings_regularizer=l2(regs[1]),
input_length=1, name='item_embedding')
# Crucial to flatten an embedding vector!
user_latent = Flatten()(MF_Embedding_User(user_input))
item_latent = Flatten()(MF_Embedding_Item(item_input))
# Element-wise product of user and item embeddings
# predict_vector = merge([user_latent, item_latent], mode = 'mul')
predict_vector = multiply([user_latent, item_latent])
# Final prediction layer
# prediction = Lambda(lambda x: K.sigmoid(K.sum(x)), output_shape=(1,))(predict_vector)
prediction = Dense(1, activation='sigmoid',
kernel_initializer=initializers.lecun_normal(), name='prediction')(predict_vector)
model_ = Model(input=[user_input, item_input], output=prediction)
return model_
上述代码是构建模型结构，首先定义Input为一维多列的数据，然后是Embedding层，Embedding主要是为了降维，就是起到了look up的作用，然后是Merge层，将用户和物品的张量进行了内积相乘(latent_dim 表示两者的潜在降维的维度是相同的，因此可以做内积)，紧接着是一个全连接层，激活函数为sigmoid。
1.2 MLP
下面是MLP.py的源码：
def get_model(num_users, num_items, layers=[20, 10], reg_layers=[0, 0]):
assert len(layers) == len(reg_layers)
num_layer = len(layers) # Number of layers in the MLP
# Input variables
user_input = Input(shape=(1,), dtype='int32', name='user_input')
item_input = Input(shape=(1,), dtype='int32', name='item_input')
MLP_Embedding_User = Embedding(input_dim=num_users, output_dim=int(layers[0]/2), name='user_embedding',
embeddings_regularizer=l2(reg_layers[0]), input_length=1)
MLP_Embedding_Item = Embedding(input_dim=num_items, output_dim=int(layers[0]/2), name='item_embedding',
embeddings_regularizer=l2(reg_layers[0]), input_length=1)
# Crucial to flatten an embedding vector!
user_latent = Flatten()(MLP_Embedding_User(user_input))
item_latent = Flatten()(MLP_Embedding_Item(item_input))
# The 0-th layer is the concatenation of embedding layers
# vector = merge([user_latent, item_latent], mode = 'concat')
vector = concatenate([user_latent, item_latent])
# MLP layers
for idx in range(1, num_layer):
layer = Dense(layers[idx], kernel_regularizer=l2(reg_layers[idx]), activation='relu', name='layer%d' % idx)
vector = layer(vector)
# Final prediction layer
prediction = Dense(1, activation='sigmoid', kernel_initializer=initializers.lecun_normal(),
name='prediction')(vector)
model_ = Model(inputs=[user_input, item_input],
outputs=prediction)
return model_
最重要的也是构建模型的部分，与GMF不同的有两个部分，首先是user_latent和item_latent的merge的部分，不再采用内积的形式，而是contract拼接的方式；再者就是for循环构建深层全连接神经网络，内部Layer的激活函数是relu，最后一层的激活函数仍然是sigmoid。
1.3 NeuMF
接下来是NeuMF.py，将MLP和GMF进行了融合，模型构建代码如下：
def get_model(num_users, num_items, mf_dim=10, layers=[10], reg_layers=[0], reg_mf=0):
assert len(layers) == len(reg_layers)
num_layer = len(layers) #Number of layers in the MLP
# Input variables
user_input = Input(shape=(1,), dtype='int32', name='user_input')
item_input = Input(shape=(1,), dtype='int32', name='item_input')
# Embedding layer
MF_Embedding_User = Embedding(input_dim=num_users, output_dim=mf_dim, name='mf_embedding_user',
embeddings_initializer=initializers.random_normal(),
embeddings_regularizer=l2(reg_mf),
input_length=1)
MF_Embedding_Item = Embedding(input_dim=num_items, output_dim=mf_dim, name='mf_embedding_item',
embeddings_initializer=initializers.random_normal(),
embeddings_regularizer=l2(reg_mf), input_length=1)
MLP_Embedding_User = Embedding(input_dim=num_users, output_dim=int(layers[0]/2), name="mlp_embedding_user",
embeddings_initializer=initializers.random_normal(),
embeddings_regularizer=l2(reg_layers[0]), input_length=1)
MLP_Embedding_Item = Embedding(input_dim=num_items, output_dim=int(layers[0]/2), name='mlp_embedding_item',
embeddings_initializer=initializers.random_normal(),
embeddings_regularizer=l2(reg_layers[0]), input_length=1)
# MF part
mf_user_latent = Flatten()(MF_Embedding_User(user_input))
mf_item_latent = Flatten()(MF_Embedding_Item(item_input))
# mf_vector = merge([mf_user_latent, mf_item_latent], mode = 'mul') # element-wise multiply
mf_vector = multiply([mf_user_latent, mf_item_latent])
# MLP part
mlp_user_latent = Flatten()(MLP_Embedding_User(user_input))
mlp_item_latent = Flatten()(MLP_Embedding_Item(item_input))
# mlp_vector = merge([mlp_user_latent, mlp_item_latent], mode = 'concat')
mlp_vector = concatenate([mlp_user_latent, mlp_item_latent])
for idx in range(1, num_layer):
layer = Dense(layers[idx], kernel_regularizer=l2(reg_layers[idx]), activation='relu', name="layer%d" % idx)
mlp_vector = layer(mlp_vector)
# Concatenate MF and MLP parts
#mf_vector = Lambda(lambda x: x * alpha)(mf_vector)
#mlp_vector = Lambda(lambda x : x * (1-alpha))(mlp_vector)
# predict_vector = merge([mf_vector, mlp_vector], mode = 'concat')
predict_vector = concatenate([mf_vector, mlp_vector])
# Final prediction layer
prediction = Dense(1, activation='sigmoid', kernel_initializer=initializers.lecun_normal(),
name="prediction")(predict_vector)
model_ = Model(inputs=[user_input, item_input],
outputs=prediction)
return model_
代码的前半部分分别是GMFe和MLP的内部layer构建过程，在 predict_vector = merge([mf_vector, mlp_vector], mode = 'concat')这一行开始对两者的输出进行了merge，方式为concat。最后包了一层的sigmoid。
2. 细节部分
看完了构建模型的代码，下面关注几个细节：
2.1 训练样本的正负比例如何设定?
def get_train_instances(train, num_negatives):
user_input, item_input, labels = [], [], []
num_users = train.shape[0]
for (u, i) in train.keys():
# positive instance
user_input.append(u)
item_input.append(i)
labels.append(1)
# negative instances
for t in range(num_negatives):
j = np.random.randint(num_items)
while (u, j) in train.keys():
j = np.random.randint(num_items)
user_input.append(u)
item_input.append(j)
labels.append(0)
return user_input, item_input, labels
该函数是获取用户和物品的训练数据，其中num_negatives控制着正负样本的比例，负样本的获取方法也简单粗暴，直接随机选取用户没有选择的其余的物品。
2.2 保存了训练的模型，该怎么对数据进行预测?我们从evalute.py中的源码中可以得到答案
def eval_one_rating(idx):
rating = _testRatings[idx]
items = _testNegatives[idx]
u = rating[0]
gtItem = rating[1]
items.append(gtItem)
# Get prediction scores
map_item_score = {}
users = np.full(len(items), u, dtype='int32')
predictions = _model.predict([users, np.array(items)],
batch_size=100, verbose=0)
for i in range(len(items)):
item = items[i]
map_item_score[item] = predictions[i]
items.pop()
# Evaluate top rank list
ranklist = heapq.nlargest(_K, map_item_score, key=map_item_score.get)
hr = getHitRatio(ranklist, gtItem)
ndcg = getNDCG(ranklist, gtItem)
return (hr, ndcg)
输入只要保证和训练的时候的格式一样即可，这里作者事先构建了negative的数据，也就是说对negative的物品和测试集合中的某一个物品进行了预测，最终选取topK的，来评测是否在其中(注getHitRatio函数不是最终结果，只是0/1) eval_one_rating 函数只是对测试集合中的某个用户的某个物品，以及和事先划分好的负样本组合在一起进行预测，最终输出该测试物品是否在topK中。
2.3
Embedding 层的物品的latent_dim和用户的latent_dim是一致的，如果不一致是否可以?在实际中未必两者的维度是一致的，这里受限于keras的merge函数的参数要求，输入的数据的shape必须是一致的，所以必须是一致的。以及Merge中的mode参数，至于什么时候选择contact，什么时候选择mul，我觉得依赖于模型效果，在实际工程中选择使得最优的方式。
2.4
python MLP.py --dataset ml-1m --epochs 20 --batch_size 256 --layers [64,32,16,8]
这是运行MLP的参数，layers的参数在逐渐减小，这也是深度神经网络的潜在设置，一般意义上越深的layer是对前面的更高层次的抽象。
网友评论