携手创造，一起生长！这是我参与「日新方案 8 月更文挑战」的第25天，点击检查活动详情

作者：韩信子@ShowMeAI 深度学习实战系列：www.showmeai.tech/tutorials/4… TensorFlow 实战系列：www.showmeai.tech/tutorials/4… 本文地址：www.showmeai.tech/article-det… 声明：版权一切，转载请联络渠道与作者并注明出处 收藏ShowMeAI检查更多精彩内容

引荐体系是猜测用户对多种产品的偏好的模型，互联网时代，它在各种范畴大放异彩，从视频音乐多媒体引荐、到电商购物引荐、社交联系引荐，无处不在地提高用户体验。

最常见的引荐体系办法包含：依据产品特征（依据内容）、用户类似性（协同过滤等近邻算法）、个人信息（依据常识）。当然，随着神经网络的日益普及，许多公司的事务中运用到的引荐算法现已是上述一切办法结合的混合引荐体系。

在本篇内容中，ShowMeAI 将给咱们一一道来，从传统引荐体系算法到前沿的新式引荐体系，解说原理并手把手教咱们如何用代码完结。

本篇内容运用到的 MovieLens 电影引荐数据集，咱们能够在 ShowMeAI 的百度网盘地址下载。

实战数据集下载（百度网盘）：大众号『ShowMeAI研究中心』回复『实战』，或许点击 这儿 获取本文 [19]依据TensorFlow搭建混合神经网络引荐体系 『MovieLens 电影引荐数据集』

⭐ ShowMeAI官方GitHub：github.com/ShowMeAI-Hu…

数据集包含观众对电影的评分成果，有不同规模的数据集巨细，咱们本篇内容中的代码通用，咱们能够依据自己的核算资源状况挑选适宜的数据集。

• 小数据集为 600 名观众对 9000部电影的 10w 个打分，也包含电影标签特征。
• 大数据集为 280000 名观众对 110w 部电影的 2700w 评分。

本文触及的内容板块如下：

• 根本设置&数据预处理
• 冷启动问题&处理
• 依据内容的办法（tensorflow 和 numpy完结）
• 传统协同过滤和神经协同过滤模型（tensorflow/keras 完结）
• 混合模型模型（上下文感知，tensorflow/keras 完结）

根本设置&数据预处理

东西库导入

首先，咱们导入所需东西库：

# 数据读取与处理
import pandas as pd
import numpy as np
import re
from datetime import datetime
# 绘图
import matplotlib.pyplot as plt
import seaborn as sns
# 点评与预处理
from sklearn import metrics, preprocessing
# 深度学习
from tensorflow.keras import models, layers, utils  #(2.6.0)

读取数据

接下来咱们读取数据。

dtf_products = pd.read_csv("movie.csv")

movie电影文件中，每一行代表一部电影，右侧的两列包含其特征（标题与体裁）。让咱们读取用户数据：

dtf_users = pd.read_csv("ratings.csv").head(10000)

这个ratings表的每一行都是观众电影对，并显现观众对电影的评分（即目标变量）。当然啦，并不是每个观众都看过一切的电影，所以咱们能够给他们引荐没有看过的电影。这儿的一种思路便是预估观众关于没有看过的电影的评分，再依据评分凹凸进行引荐。

数据剖析&特征工程

在实践发掘与建模之前，咱们先做一些数据整理和特征工程的作业，让数据更洁净和合适建模运用。

数据剖析部分触及的东西库，咱们能够参阅ShowMeAI制作的东西库速查表和教程进行学习和快速运用。 数据科学东西库速查表 | Pandas 速查表 图解数据剖析：从入门到精通系列教程

# 电影数据处理
# 体裁字段缺失处理
dtf_products = dtf_products[~dtf_products["genres"].isna()]
dtf_products["product"] = range(0,len(dtf_products))
# 电影名称处理
dtf_products["name"] = dtf_products["title"].apply(lambda x: re.sub("[([].*?[)]]", "", x).strip())
# 日期
dtf_products["date"] = dtf_products["title"].apply(lambda x: int(x.split("(")[-1].replace(")","").strip()) 
if "(" in x else np.nan)
dtf_products["date"] = dtf_products["date"].fillna(9999)
# 判断老电影
dtf_products["old"] = dtf_products["date"].apply(lambda x: 1 if x < 2000 else 0)
# 观众/用户数据处理
dtf_users["user"] = dtf_users["userId"].apply(lambda x: x-1)
dtf_users["timestamp"] = dtf_users["timestamp"].apply(lambda x: datetime.fromtimestamp(x))
# 白日时段
dtf_users["daytime"] = dtf_users["timestamp"].apply(lambda x: 1 if 6<int(x.strftime("%H"))<20 else 0)
# 周末
dtf_users["weekend"] = dtf_users["timestamp"].apply(lambda x: 1 if x.weekday() in [5,6] else 0)
# 电影与用户表兼并
dtf_users = dtf_users.merge(dtf_products[["movieId","product"]], how="left")
dtf_users = dtf_users.rename(columns={"rating":"y"})
# 清洗数据
dtf_products = dtf_products[["product","name","old","genres"]].set_index("product")
dtf_users = dtf_users[["user","product","daytime","weekend","y"]]

上述过程中有一些很贴合场景的特征工程和数据生成作业，比方咱们从时间戳中生成了2个新的字段： 『是否白日』 和 『是否周末』 。

dtf_context = dtf_users[["user","product","daytime","weekend"]]

下一步咱们构建 Moives-Features 矩阵：

# 电影体裁候选核算
tags = [i.split("|") for i in dtf_products["genres"].unique()]
columns = list(set([i for lst in tags for i in lst]))
columns.remove('(no genres listed)')
# 体裁或许有多个，切分出来作为标签
for col in columns:
    dtf_products[col] = dtf_products["genres"].apply(lambda x: 1 if col in x else 0)

咱们得到的这个『电影-体裁』矩阵是稀疏的（很好了解，一般一部电影只归属于有限的几个体裁）。咱们做一点可视化以更好地了解状况，代码如下：

# 构建热力求并可视化
fig, ax = plt.subplots(figsize=(20,5))
sns.heatmap(dtf_products==0, vmin=0, vmax=1, cbar=False, ax=ax).set_title("Products x Features")
plt.show() 

下面是咱们的 『观众/用户-电影』 评分矩阵，咱们发现它更为稀疏（每位用户实践只看过几部电影，但总电影量很大）

tmp = dtf_users.copy()
dtf_users = tmp.pivot_table(index="user", columns="product", values="y")
missing_cols = list(set(dtf_products.index) - set(dtf_users.columns))
for col in missing_cols:
    dtf_users[col] = np.nan
dtf_users = dtf_users[sorted(dtf_users.columns)]

同样的热力求成果如下：

在特征工程部分，咱们需求做一些典型的数据预处理过程，比方咱们会在后续用到神经网络模型，而这种核算型模型，咱们对数据做幅度缩放是十分必要的。

关于机器学习特征工程，咱们能够参阅 ShowMeAI 整理的特征工程最全解读教程。

机器学习实战 | 机器学习特征工程最全解读

# 数据幅度缩放
dtf_users = pd.DataFrame(preprocessing.MinMaxScaler(feature_range=(0.5,1)).fit_transform(dtf_users.values), 
columns=dtf_users.columns, index=dtf_users.index)

数据切分

简略处理完数据之后，就像任何典型的机器学习使命相同，咱们需求对数据进行划分，在这儿划分为练习集和测验集。假如结合上述『用户-电影』矩阵，咱们会做类似下图的笔直切分，这样练习集和测验集都会尽量覆盖一切用户：

# 数据切分
split = int(0.8*dtf_users.shape[1])
dtf_train = dtf_users.loc[:, :split-1]
dtf_test = dtf_users.loc[:, split:]

冷启动问题&处理

冷启动问题

幻想一下，类似于『抖音』这样的应用，关于新用户供给引荐，其实是不太精确的（只能依据一些战略，如热度排行等进行引荐），咱们对用户的信息积累太少，用户画像的作业无法进行。这便是任何一个引荐体系产品都会遇到的冷启动问题（即由于没有足够的前史数据，体系无法在用户和产品之间建立任何相关）。

冷启动处理办法

针对冷启动问题，有一些典型的处理方式，例如依据常识的办法：在初次进入APP时问询用户的偏好，构建根本信息与常识，再依据常识进行引荐（比方不同『年纪段』和『性别』喜爱的媒体产品等）。

别的一种处理办法是依据内容的办法。即依据产品的特点（比方咱们当时的场景下，电影的体裁、艺人、主题等）进行匹配引荐。

依据内容的引荐办法

中心思维

咱们来介绍一下依据内容的办法。

这个办法是依据产品特点进行相关和引荐的，例如，假如『用户A喜爱产品1』，而且『产品2与产品1从特点上看类似』，那么『用户A或许也会喜爱产品2』。简略地说，这个想法是『用户实践上对产品的功用/特点而不是产品本身进行评分』。

换句话说，假如我喜爱与音乐和艺术相关的产品，那是由于我喜爱那些功用/特点（音乐和艺术）。咱们能够依据这个信息做引荐。

代码完结

咱们随机从数据中挑选一个『观众/用户』作为咱们的新用户的示例，该订阅者现在现已运用了足够多的产品，让咱们创建练习和测验向量。

# 选一个user
i = 1
train = dtf_train.iloc[i].to_frame(name="y")
test = dtf_test.iloc[i].to_frame(name="y")
# 把一切测验集的电影评分清空后拼接
tmp = test.copy()
tmp["y"] = np.nan
train = train.append(tmp)

下面咱们估测『观众/用户』对每个特征的权重，回到咱们前面整理完的 User-Products 矩阵和 Products-Features 矩阵。

# 数据维度
usr = train[["y"]].fillna(0).values.T
prd = dtf_products.drop(["name","genres"],axis=1).values
print("Users", usr.shape, " x  Products", prd.shape)

咱们把这 2 个矩阵相乘，咱们获得了一个『用户-特征』矩阵，它包含这个用户对每个特征的估计权重。咱们进而把这些权重应重新应用于『产品-特征』矩阵就能够获得测验集成果。

# usr_ft(users,fatures) = usr(users,products) x prd(products,features)
usr_ft = np.dot(usr, prd)
# 归一化
weights = usr_ft / usr_ft.sum()
# 预估打分 rating(users,products) = weights(users,fatures) x prd.T(features,products)
pred = np.dot(weights, prd.T)
test = test.merge(pd.DataFrame(pred[0], columns=["yhat"]), how="left", left_index=True, right_index=True).reset_index()
test = test[~test["y"].isna()]
test

上面是一个十分十分简略的思路，咱们用 numpy 对它进行了完结。其实这个过程也能够在原始数据张量上进行：

# 依据tensorflow更高效的完结
import tensorflow as tf
# usr_ft(users,fatures) = usr(users,products) x prd(products,features)
usr_ft = tf.matmul(usr, prd)
# normalize
weights = usr_ft / tf.reduce_sum(usr_ft, axis=1, keepdims=True)
# rating(users,products) = weights(users,fatures) x prd.T(features,products)
pred = tf.matmul(weights, prd.T)

只是完结预估过程还不够，咱们需求对猜测引荐进行有效点评，怎么做呢，在当时这个引荐场景下，咱们能够运用精确性和均匀倒数排名（MRR，一种针对排序作用的核算衡量）。

# 点评目标
def mean_reciprocal_rank(y_test, predicted):
    score = []
    for product in y_test:
        mrr = 1 / (list(predicted).index(product) + 1) if product 
        in predicted else 0
        score.append(mrr)
    return np.mean(score)

有时分，在悉数排序成果列表上点评，作用一般且核算量太大，咱们能够挑选标准答案的 top k 进行点评（下面代码中 k 取值为 5）。

print("--- user", i, "---")
top = 5
y_test = test.sort_values("y", ascending=False)["product"].values[:top]
print("y_test:", y_test)
predicted = test.sort_values("yhat", ascending=False)["product"].values[:top]
print("predicted:", predicted)
true_positive = len(list(set(y_test) & set(predicted)))
print("true positive:", true_positive, "("+str(round(true_positive/top*100,1))+"%)")
print("accuracy:", str(round(metrics.accuracy_score(y_test,predicted)*100,1))+"%")
print("mrr:", mean_reciprocal_rank(y_test, predicted))

上图显现在 user1 上，咱们预估成果和 top5 实在成果，有 4 个成果是重叠的。（不过由于咱们预估成果的序并不完全和标准答案相同，所以目标上看 accuracy 和 mrr 会低一点）

# 检查预估成果细节
test.merge(
       dtf_products[["name","old","genres"]], left_on="product", 
       right_index=True
).sort_values("yhat", ascending=False)

协同过滤引荐算法

中心思维

协同过滤是一类典型的『近邻』引荐算法，依据用户和用户的类似性，或许产品和产品的类似性来构建引荐。比方 user-based collaborative filtering（依据用户的协同过滤）中，咱们认为『用户A喜爱产品1』，而依据用户行为核算判定『用户B和用户A类似』，那么『用户B或许也会喜爱产品1』。

注意到协同过滤算法中，很重要的过程是咱们需求依据用户前史的行为来构建类似度衡量（user-user 或 item-item 类似度）。

协同过滤和上面说到的依据内容的引荐算法不同，咱们不需求产品特点来建模，而是依据大量用户的前史行为来核算和构建类似衡量（例如在本例中，咱们能够依据不同的观众前史上在一批电影上的评分类似度来构建）。

根底协同过滤算法

协同过滤是**『依据用户行为』**的引荐算法，咱们会『经过群体的行为来找到某种类似性』（用户之间的类似性或许物品之间的类似性），经过类似性来为用户做决议计划和引荐。协同过滤细分一下，有以下依据邻域的、依据隐语义模型2大类办法。

依据近邻的协同过滤

依据近邻的协同过滤包含 user-based cf（依据用户的协同过滤）和 item-based cf（依据物品的协同过滤）两种方式，中心思维如下图所示：

中心过程为以下3步：

① 依据前史数据收集用户偏好（比方本例中的打分，比方）。

② 找到类似的用户（依据用户）或物品（依据物品）。

③ 依据类似性核算和引荐。

其中的 similarity 类似度核算部分，能够依据一些衡量准则来完结，比方最常用到的类似度衡量是余弦类似度：

在本例中A和B能够是两个用户的一起电影对应的打分向量，或许两部电影的一起打分用户的打分向量，也便是打分矩阵中的两行或许两列。

当然，咱们也能够依据聚类等其他办法来发现类似用户和物品。

依据隐语义模型的协同过滤

协同过滤的别的一种完结，是依据矩阵分化的办法，在本例中经过这个办法能够猜测用户对某个产品的点评，矩阵分化办法将大的『用户-物品 **』**打分矩阵分成两个较小的因子矩阵，别离是『**用户-因子』**矩阵和『**产品-因子』**矩阵，再依据这两个矩阵关于未打分的『**用户-物品』**对打分。

具体来说，每个因子或许代表某一个特点维度的程度，如下如，咱们假如确定2个特点『年纪段』『体裁娱乐性』，那咱们能够依据打分矩阵对这两个维度进行分化。

代码完结

在 Python 中，要完结上述说到的2类协同过滤算法，最方便的东西库之一是 scikit-surprise（从名字咱们能够看出，它借助了 scikit-learn 的一些底层算法来完结上层的协同过滤）。它包含了上述说到的依据近邻的协同过滤和依据隐语义模型的协同过滤。

不过矩阵完结办法也是各种深度学习模型所擅长的，咱们在这儿运用tensorflow/keras来做一点完结。

咱们先准备好『**用户-物品』**数据（本例中的用户是观众，物品是电影）：

train = dtf_train.stack(dropna=True).reset_index().rename(columns={0:"y"})
train.head()

咱们会运用神经网络的嵌入层来创建『**用户-因子』**和『**产品-因子』**矩阵，这儿特别合适用神经网络的 embedding 层来完结映射矩阵构建，咱们为用户和产品别离构建 embedding 矩阵。Embedding 矩阵的维度便是咱们这个当地设定的因子的个数。下面咱们运用 tensorflow 来完结这个过程。

embeddings_size = 50
usr, prd = dtf_users.shape[0], dtf_users.shape[1]
# 用户 Users 维度(1,embedding_size)
xusers_in = layers.Input(name="xusers_in", shape=(1,))
xusers_emb = layers.Embedding(name="xusers_emb", input_dim=usr, output_dim=embeddings_size)(xusers_in)
xusers = layers.Reshape(name='xusers', target_shape=(embeddings_size,))(xusers_emb)
# 产品 Products 维度(1,embedding_size)
xproducts_in = layers.Input(name="xproducts_in", shape=(1,))
xproducts_emb = layers.Embedding(name="xproducts_emb", input_dim=prd, output_dim=embeddings_size)(xproducts_in)
xproducts = layers.Reshape(name='xproducts', target_shape=(embeddings_size,))(xproducts_emb)
# 矩阵乘法，即咱们咱们上面说到的因子矩阵相乘 维度(1)
xx = layers.Dot(name='xx', normalize=True, axes=1)([xusers, xproducts])
# 猜测得分 维度(1)
y_out = layers.Dense(name="y_out", units=1, activation='linear')(xx)
# 编译
model = models.Model(inputs=[xusers_in,xproducts_in], outputs=y_out, name="CollaborativeFiltering")
model.compile(optimizer='adam', loss='mean_absolute_error', metrics=['mean_absolute_percentage_error'])

在本例中呢，由于咱们终究是对电影的评分去做猜测，所以咱们把这个问题视作一个回归的问题运用模型来处理，咱们会运用均匀绝对误差作为终究的损失函数。当然咱们实践在处理引荐这个问题的时分，或许并不需求得到精确的得分，而是希望依据这些得分去完结一个排序和终究的引荐。

咱们把构建出来的模型示意图和中间层的维度打印一下，方便咱们检查，如下

utils.plot_model(model, to_file='model.png', show_shapes=True, show_layer_names=True)

接下来咱们就能够在咱们的数据上去练习、点评和测验咱们的模型了。

# 练习
training = model.fit(x=[train["user"], train["product"]], y=train["y"], epochs=100, batch_size=128, shuffle=True, verbose=0, validation_split=0.3)
model = training.model
# 测验
test["yhat"] = model.predict([test["user"], test["product"]])
test

在这个模型终究的预估成果上，咱们能够看到模型现已能够对没有见过的新的电影进行打分的猜测了。咱们能够依据这个得分进行排序和完结终究的引荐。以咱们第1个用户为例，咱们能够看到关于他进行依据猜测得分的引荐，点评成果如下。

神经协同过滤算法

模型介绍

咱们在前面看到的协同过滤模型，学习能力相对比较弱，关于咱们的信息做的是开始的发掘，而现代的许多新的引荐体系实践上都运用了深度学习。也能够把深度学习和协同过滤结合，例如 Neural Collaborative Filtering (2017) 结合了来自神经网络的非线性和矩阵分化。该模型旨在充分运用嵌入空间，不只将其用于传统的协同过滤，还用于完全衔接的深度神经网络，新增加的模型组成部分会捕获矩阵分化或许遗漏的模式和特征，如下图所示：

代码完结

下面咱们来完结一下这个模型的一个简易版本：

# 用户与产品的embedding维度，相当于协同过滤中的因子数
embeddings_size = 50
usr, prd = dtf_users.shape[0], dtf_users.shape[1]
# 输入层
xusers_in = layers.Input(name="xusers_in", shape=(1,))
xproducts_in = layers.Input(name="xproducts_in", shape=(1,))
# A) 模型左边：Matrix Factorization 矩阵分化
# embeddings 与 reshape
cf_xusers_emb = layers.Embedding(name="cf_xusers_emb", input_dim=usr, output_dim=embeddings_size)(xusers_in)
cf_xusers = layers.Reshape(name='cf_xusers', target_shape=(embeddings_size,))(cf_xusers_emb)
# embeddings 与 reshape
cf_xproducts_emb = layers.Embedding(name="cf_xproducts_emb", input_dim=prd, output_dim=embeddings_size)(xproducts_in)
cf_xproducts = layers.Reshape(name='cf_xproducts', target_shape=(embeddings_size,))(cf_xproducts_emb)
# 产品 product
cf_xx = layers.Dot(name='cf_xx', normalize=True, axes=1)([cf_xusers, cf_xproducts])
# B) 模型右侧：Neural Network 神经网络
# embeddings 与 reshape
nn_xusers_emb = layers.Embedding(name="nn_xusers_emb", input_dim=usr, output_dim=embeddings_size)(xusers_in)
nn_xusers = layers.Reshape(name='nn_xusers', target_shape=(embeddings_size,))(nn_xusers_emb)
# embeddings 与 reshape
nn_xproducts_emb = layers.Embedding(name="nn_xproducts_emb", input_dim=prd, output_dim=embeddings_size)(xproducts_in)
nn_xproducts = layers.Reshape(name='nn_xproducts', target_shape=(embeddings_size,))(nn_xproducts_emb)
# 拼接与全衔接处理
nn_xx = layers.Concatenate()([nn_xusers, nn_xproducts])
nn_xx = layers.Dense(name="nn_xx", units=int(embeddings_size/2), activation='relu')(nn_xx)
# 兼并A和B
y_out = layers.Concatenate()([cf_xx, nn_xx])
y_out = layers.Dense(name="y_out", units=1, activation='linear')(y_out)
# 编译
model = models.Model(inputs=[xusers_in,xproducts_in], outputs=y_out, name="Neural_CollaborativeFiltering")
model.compile(optimizer='adam', loss='mean_absolute_error', metrics=['mean_absolute_percentage_error']) 

咱们也同样能够对模型进行结构的绘制，如下所示。

utils.plot_model(model, to_file=’model.png’, show_shapes=True, show_layer_names=True)

咱们再依据现在这个神经网络的模型，去对咱们终究的电影打评分进行猜测，而且依据猜测的得分进行排序和引荐，那点评的成果如下所示。

混合网络模型

模型介绍

咱们在前面展现了如何结合咱们的用户和产品（在当时场景下是电影引荐的场景）的打分数据来构建协同过滤算法和根底的神经网络算法，完结终究打分的猜测和引荐，但实践咱们的数据傍边有着更丰厚的信息。

• 用户行为 ： 当时场景下是电影的打分，它是一种显式用户反馈；有些场景下咱们会运用隐式的用户反馈，比方说用户的点击或许深度阅读和完播等行为。
• 产品信息 ： 产品的标签和描述（这儿的电影体裁、标题等），主要用于依据内容的办法。
• 用户信息 ： 人口核算学信息（即性别和年纪）或行为（即偏好、屏幕上的均匀时间、最频繁的运用时间），主要用于依据常识的引荐。
• 上下文 ： 关于评分状况的附加信息（如何时、何地、搜索前史），一般也包含在依据常识的引荐中。

现代引荐体系为了更精准的给咱们进行引荐，会尽量的结合一切咱们能够收集到的信息。咱们日常运用的抖音或许B站，它们在给咱们引荐视频类的内容的时分，会更加全面的运用咱们上面提及到的一切的信息，乃至包含APP能采集到的更丰厚的信息。

代码完结

下面结合本例，咱们也把这些更丰厚的信息（主要是上下文信息）结合到网络中来构建一个混合模型，以完结更精准的预估和引荐。

# 根底特征
features = dtf_products.drop(["genres","name"], axis=1).columns
print(features)
# 上下文特征（时间段、作业日、周末等）
context = dtf_context.drop(["user","product"], axis=1).columns
print(context)

根底特征和上下文特征如下

接下来咱们把这些额外信息增加到练习集中：

train = dtf_train.stack(dropna=True).reset_index().rename(columns={0:"y"})
# 增加特征
train = train.merge(dtf_products[features], how="left", left_on="product", right_index=True)
# 增加上下文信息
train = train.merge(dtf_context, how="left")

注意咱们这儿并没有对测验集直接去履行相同的操作，由于实践的出产环境傍边，咱们或许没有办法提早的去获知一些上下文的信息，所以咱们会为上下文的信息去刺进一个静态的值去做填充。

当然咱们在实践预估的时分，是能够比较精确的去做填充的。比方咱们在星期一晚上为咱们渠道的用户进行猜测，则上下文变量应为 daytime=0 和 week=0 。

下面咱们来构建上下文感知混合模型，神经网络的结构十分灵活，咱们能够在网络中增加任何咱们想要补充的信息，咱们把上下文等额外信息也经过网络组件的形式补充到神经协同过滤网络结构中，如下所示。

这个过程就相当于在刚才的神经协同过滤模型根底上，增加一些新的组块。下列完结代码看起来比较庞大，但实践上它只是在之前的完结根底上增加了一些行而已：

embeddings_size = 50
usr, prd = dtf_users.shape[0], dtf_users.shape[1]
feat = len(features)
ctx = len(context)
################## 神经协同过滤 ########################
# 输入层
xusers_in = layers.Input(name="xusers_in", shape=(1,))
xproducts_in = layers.Input(name="xproducts_in", shape=(1,))
# A) 模型左边：Matrix Factorization 矩阵分化
# embeddings 与 reshape
cf_xusers_emb = layers.Embedding(name="cf_xusers_emb", input_dim=usr, output_dim=embeddings_size)(xusers_in)
cf_xusers = layers.Reshape(name='cf_xusers', target_shape=(embeddings_size,))(cf_xusers_emb)
# embeddings 与 reshape
cf_xproducts_emb = layers.Embedding(name="cf_xproducts_emb", input_dim=prd, output_dim=embeddings_size)(xproducts_in)
cf_xproducts = layers.Reshape(name='cf_xproducts', target_shape=(embeddings_size,))(cf_xproducts_emb)
# 产品 product
cf_xx = layers.Dot(name='cf_xx', normalize=True, axes=1)([cf_xusers, cf_xproducts])
# B) 模型右侧：Neural Network 神经网络
# embeddings 与 reshape
nn_xusers_emb = layers.Embedding(name="nn_xusers_emb", input_dim=usr, output_dim=embeddings_size)(xusers_in)
nn_xusers = layers.Reshape(name='nn_xusers', target_shape=(embeddings_size,))(nn_xusers_emb)
# embeddings 与 reshape
nn_xproducts_emb = layers.Embedding(name="nn_xproducts_emb", input_dim=prd, output_dim=embeddings_size)(xproducts_in)
nn_xproducts = layers.Reshape(name='nn_xproducts', target_shape=(embeddings_size,))(nn_xproducts_emb)
# 拼接与全衔接处理
nn_xx = layers.Concatenate()([nn_xusers, nn_xproducts])
nn_xx = layers.Dense(name="nn_xx", units=int(embeddings_size/2), activation='relu')(nn_xx)
######################## 根底信息 ############################
# 电影特征
features_in = layers.Input(name="features_in", shape=(feat,))
features_x = layers.Dense(name="features_x", units=feat, activation='relu')(features_in)
####################### 上下文特征 ###########################
# 上下文特征
contexts_in = layers.Input(name="contexts_in", shape=(ctx,))
context_x = layers.Dense(name="context_x", units=ctx, activation='relu')(contexts_in)
######################### 输出 ##################################
# 兼并一切信息
y_out = layers.Concatenate()([cf_xx, nn_xx, features_x, context_x])
y_out = layers.Dense(name="y_out", units=1, activation='linear')(y_out)
# 编译
model = models.Model(inputs=[xusers_in,xproducts_in, features_in, contexts_in], outputs=y_out, name="Hybrid_Model")
model.compile(optimizer='adam', loss='mean_absolute_error', metrics=['mean_absolute_percentage_error'])

咱们也绘制一下整个模型的结构

utils.plot_model(model, to_file='model.png', show_shapes=True, show_layer_names=True)

混合模型的输入数据源更多，实践练习时咱们要把这些数据都送入模型：

# 练习
training = model.fit(x=[train["user"], train["product"], train[features], train[context]], y=train["y"], 
                     epochs=100, batch_size=128, shuffle=True, verbose=0, validation_split=0.3)
model = training.model
# 猜测
test["yhat"] = model.predict([test["user"], test["product"], test[features], test[context]])

终究依据混合模型的猜测得分进行引荐，点评目标如下：

咱们独自看 user1 这个用户，混合模型在多种信息的支撑下，获得了最高的精确度。

定论

本文解说了引荐体系的根底常识，以及不同的引荐体系搭建办法，咱们对各种办法进行了完结和作用改进，包含依据内容的引荐完结，依据协同过滤的引荐完结，咱们把更丰厚的产品信息和上下文信息加入网络完结了混合网络模型。咱们能够参阅完结流程应用在自己的场景中。

参阅资料

• 数据科学东西库速查表 | Pandas 速查表：www.showmeai.tech/article-det…
• 图解数据剖析：从入门到精通系列教程：www.showmeai.tech/tutorials/3…
• 机器学习实战 | 机器学习特征工程最全解读：www.showmeai.tech/article-det…
• scikit-surprise：pypi.org/project/sci…