个性化推荐

本教程源代码目录在book/recommender_system,初次使用请您参考Book文档使用说明。

说明:

  • 硬件环境要求：本文可支持在CPU、GPU下运行
  • Docker镜像支持的CUDA/cuDNN版本：如果使用了Docker运行Book，请注意：这里所提供的默认镜像的GPU环境为 CUDA 8/cuDNN 5，对于NVIDIA Tesla V100等要求CUDA 9的 GPU，使用该镜像可能会运行失败。
  • 文档和脚本中代码的一致性问题：请注意：为使本文更加易读易用，我们拆分、调整了train.py的代码并放入本文。本文中代码与train.py的运行结果一致，可直接运行train.py进行验证。

背景介绍

在网络技术不断发展和电子商务规模不断扩大的背景下，商品数量和种类快速增长，用户需要花费大量时间才能找到自己想买的商品，这就是信息超载问题。为了解决这个难题，个性化推荐系统（Recommender System）应运而生。

个性化推荐系统是信息过滤系统（Information Filtering System）的子集，它可以用在很多领域，如电影、音乐、电商和 Feed 流推荐等。个性化推荐系统通过分析、挖掘用户行为，发现用户的个性化需求与兴趣特点，将用户可能感兴趣的信息或商品推荐给用户。与搜索引擎不同，个性化推荐系统不需要用户准确地描述出自己的需求，而是根据用户的历史行为进行建模，主动提供满足用户兴趣和需求的信息。

1994年明尼苏达大学推出的GroupLens系统[1]一般被认为是个性化推荐系统成为一个相对独立的研究方向的标志。该系统首次提出了基于协同过滤来完成推荐任务的思想，此后，基于该模型的协同过滤推荐引领了个性化推荐系统十几年的发展方向。

传统的个性化推荐系统方法主要有：

  • 协同过滤推荐（Collaborative Filtering Recommendation）：该方法是应用最广泛的技术之一，需要收集和分析用户的历史行为、活动和偏好。它通常可以分为两个子类：基于用户 （User-Based）的推荐[1] 和基于物品（Item-Based）的推荐[2]。该方法的一个关键优势是它不依赖于机器去分析物品的内容特征，因此它无需理解物品本身也能够准确地推荐诸如电影之类的复杂物品；缺点是对于没有任何行为的新用户存在冷启动的问题，同时也存在用户与商品之间的交互数据不够多造成的稀疏问题。值得一提的是，社交网络[3]或地理位置等上下文信息都可以结合到协同过滤中去。
  • 基于内容过滤推荐[4]（Content-based Filtering Recommendation）：该方法利用商品的内容描述，抽象出有意义的特征，通过计算用户的兴趣和商品描述之间的相似度，来给用户做推荐。优点是简单直接，不需要依据其他用户对商品的评价，而是通过商品属性进行商品相似度度量，从而推荐给用户所感兴趣商品的相似商品；缺点是对于没有任何行为的新用户同样存在冷启动的问题。
  • 组合推荐[5]（Hybrid Recommendation）：运用不同的输入和技术共同进行推荐，以弥补各自推荐技术的缺点。近些年来，深度学习在很多领域都取得了巨大的成功。学术界和工业界都在尝试将深度学习应用于个性化推荐系统领域中。深度学习具有优秀的自动提取特征的能力，能够学习多层次的抽象特征表示，并对异质或跨域的内容信息进行学习，可以一定程度上处理个性化推荐系统冷启动问题[6]。本教程主要介绍个性化推荐的深度学习模型，以及如何使用PaddlePaddle实现模型。

效果展示

我们使用包含用户信息、电影信息与电影评分的数据集作为个性化推荐的应用场景。当我们训练好模型后，只需要输入对应的用户ID和电影ID，就可以得出一个匹配的分数（范围[0,5]，分数越高视为兴趣越大），然后根据所有电影的推荐得分排序，推荐给用户可能感兴趣的电影。

  1. Input movie_id: 1962
  2. Input user_id: 1
  3. Prediction Score is 4.25

模型概览

本章中，我们首先介绍YouTube的视频个性化推荐系统[7]，然后介绍我们实现的融合推荐模型。

YouTube的深度神经网络个性化推荐系统

YouTube是世界上最大的视频上传、分享和发现网站，YouTube个性化推荐系统为超过10亿用户从不断增长的视频库中推荐个性化的内容。整个系统由两个神经网络组成：候选生成网络和排序网络。候选生成网络从百万量级的视频库中生成上百个候选，排序网络对候选进行打分排序，输出排名最高的数十个结果。系统结构如图1所示：

个性化推荐 - 图1图1. YouTube 个性化推荐系统结构

候选生成网络（Candidate Generation Network）

候选生成网络将推荐问题建模为一个类别数极大的多类分类问题：对于一个Youtube用户，使用其观看历史（视频ID）、搜索词记录（search tokens）、人口学信息（如地理位置、用户登录设备）、二值特征（如性别，是否登录）和连续特征（如用户年龄）等，对视频库中所有视频进行多分类，得到每一类别的分类结果（即每一个视频的推荐概率），最终输出概率较高的几百个视频。

首先，将观看历史及搜索词记录这类历史信息，映射为向量后取平均值得到定长表示；同时，输入人口学特征以优化新用户的推荐效果，并将二值特征和连续特征归一化处理到[0, 1]范围。接下来，将所有特征表示拼接为一个向量，并输入给非线形多层感知器（MLP，详见识别数字教程）处理。最后，训练时将MLP的输出给softmax做分类，预测时计算用户的综合特征（MLP的输出）与所有视频的相似度，取得分最高的

个性化推荐 - 图2个作为候选生成网络的筛选结果。图2显示了候选生成网络结构。

个性化推荐 - 图3图2. 候选生成网络结构

对于一个用户

个性化推荐 - 图4，预测此刻用户要观看的视频个性化推荐 - 图5为视频个性化推荐 - 图6的概率公式为：

个性化推荐 - 图7

其中

个性化推荐 - 图8为用户个性化推荐 - 图9的特征表示，个性化推荐 - 图10为视频库集合，个性化推荐 - 图11为视频库中第个性化推荐 - 图12个视频的特征表示。个性化推荐 - 图13和个性化推荐 - 图14为长度相等的向量，两者点积可以通过全连接层实现。

考虑到softmax分类的类别数非常多，为了保证一定的计算效率：1）训练阶段，使用负样本类别采样将实际计算的类别数缩小至数千；2）推荐（预测）阶段，忽略softmax的归一化计算（不影响结果），将类别打分问题简化为点积（dot product）空间中的最近邻（nearest neighbor）搜索问题，取与

个性化推荐 - 图15最近的个性化推荐 - 图16个视频作为生成的候选。

排序网络（Ranking Network）

排序网络的结构类似于候选生成网络，但是它的目标是对候选进行更细致的打分排序。和传统广告排序中的特征抽取方法类似，这里也构造了大量的用于视频排序的相关特征（如视频 ID、上次观看时间等）。这些特征的处理方式和候选生成网络类似，不同之处是排序网络的顶部是一个加权逻辑回归（weighted logistic regression），它对所有候选视频进行打分，从高到底排序后将分数较高的一些视频返回给用户。

融合推荐模型

本节会使用卷积神经网络（Convolutional Neural Networks）来学习电影名称的表示。下面会依次介绍文本卷积神经网络以及融合推荐模型。

文本卷积神经网络（CNN）

卷积神经网络经常用来处理具有类似网格拓扑结构（grid-like topology）的数据。例如，图像可以视为二维网格的像素点，自然语言可以视为一维的词序列。卷积神经网络可以提取多种局部特征，并对其进行组合抽象得到更高级的特征表示。实验表明，卷积神经网络能高效地对图像及文本问题进行建模处理。

卷积神经网络主要由卷积（convolution）和池化（pooling）操作构成，其应用及组合方式灵活多变，种类繁多。本小结我们以如图3所示的网络进行讲解：

个性化推荐 - 图17图3. 卷积神经网络文本分类模型

假设待处理句子的长度为

个性化推荐 - 图18，其中第个性化推荐 - 图19个词的词向量为个性化推荐 - 图20，个性化推荐 - 图21为维度大小。

首先，进行词向量的拼接操作：将每

个性化推荐 - 图22个词拼接起来形成一个大小为个性化推荐 - 图23的词窗口，记为个性化推荐 - 图24，它表示词序列个性化推荐 - 图25的拼接，其中，个性化推荐 - 图26表示词窗口中第一个词在整个句子中的位置，取值范围从个性化推荐 - 图27到个性化推荐 - 图28，个性化推荐 - 图29。

其次，进行卷积操作：把卷积核(kernel)

个性化推荐 - 图30应用于包含个性化推荐 - 图31个词的窗口个性化推荐 - 图32，得到特征个性化推荐 - 图33，其中个性化推荐 - 图34为偏置项（bias），个性化推荐 - 图35为非线性激活函数，如个性化推荐 - 图36。将卷积核应用于句子中所有的词窗口个性化推荐 - 图37，产生一个特征图（feature map）：

个性化推荐 - 图38

接下来，对特征图采用时间维度上的最大池化（max pooling over time）操作得到此卷积核对应的整句话的特征

个性化推荐 - 图39，它是特征图中所有元素的最大值：

个性化推荐 - 图40

融合推荐模型概览

在融合推荐模型的电影个性化推荐系统中：

  • 首先，使用用户特征和电影特征作为神经网络的输入，其中：

  • 用户特征融合了四个属性信息，分别是用户ID、性别、职业和年龄。

  • 电影特征融合了三个属性信息，分别是电影ID、电影类型ID和电影名称。

  • 对用户特征，将用户ID映射为维度大小为256的向量表示，输入全连接层，并对其他三个属性也做类似的处理。然后将四个属性的特征表示分别全连接并相加。

  • 对电影特征，将电影ID以类似用户ID的方式进行处理，电影类型ID以向量的形式直接输入全连接层，电影名称用文本卷积神经网络得到其定长向量表示。然后将三个属性的特征表示分别全连接并相加。

  • 得到用户和电影的向量表示后，计算二者的余弦相似度作为个性化推荐系统的打分。最后，用该相似度打分和用户真实打分的差异的平方作为该回归模型的损失函数。

个性化推荐 - 图41图4. 融合推荐模型

数据准备

数据介绍与下载

我们以 MovieLens 百万数据集（ml-1m）为例进行介绍。ml-1m 数据集包含了 6,000 位用户对 4,000 部电影的 1,000,000 条评价（评分范围 1~5 分，均为整数），由 GroupLens Research 实验室搜集整理。

Paddle在API中提供了自动加载数据的模块。数据模块为 paddle.dataset.movielens

  1. import paddle
  2. movie_info = paddle.dataset.movielens.movie_info()
  3. print movie_info.values()[0]
  1. # Run this block to show dataset's documentation
  2. # help(paddle.dataset.movielens)

在原始数据中包含电影的特征数据，用户的特征数据，和用户对电影的评分。

例如，其中某一个电影特征为:

  1. movie_info = paddle.dataset.movielens.movie_info()
  2. print movie_info.values()[0]
  1. <MovieInfo id(1), title(Toy Story ), categories(['Animation', "Children's", 'Comedy'])>

这表示，电影的id是1，标题是《Toy Story》，该电影被分为到三个类别中。这三个类别是动画，儿童，喜剧。

  1. user_info = paddle.dataset.movielens.user_info()
  2. print user_info.values()[0]
  1. <UserInfo id(1), gender(F), age(1), job(10)>

这表示，该用户ID是1，女性，年龄比18岁还年轻。职业ID是10。

其中，年龄使用下列分布

  • 1: "Under 18"
  • 18: "18-24"
  • 25: "25-34"
  • 35: "35-44"
  • 45: "45-49"
  • 50: "50-55"

  • 56: "56+"职业是从下面几种选项里面选则得出:

  • 0: "other" or not specified

  • 1: "academic/educator"
  • 2: "artist"
  • 3: "clerical/admin"
  • 4: "college/grad student"
  • 5: "customer service"
  • 6: "doctor/health care"
  • 7: "executive/managerial"
  • 8: "farmer"
  • 9: "homemaker"
  • 10: "K-12 student"
  • 11: "lawyer"
  • 12: "programmer"
  • 13: "retired"
  • 14: "sales/marketing"
  • 15: "scientist"
  • 16: "self-employed"
  • 17: "technician/engineer"
  • 18: "tradesman/craftsman"
  • 19: "unemployed"
  • 20: "writer"而对于每一条训练/测试数据，均为 <用户特征> + <电影特征> + 评分。

例如，我们获得第一条训练数据:

  1. train_set_creator = paddle.dataset.movielens.train()
  2. train_sample = next(train_set_creator())
  3. uid = train_sample[0]
  4. mov_id = train_sample[len(user_info[uid].value())]
  5. print "User %s rates Movie %s with Score %s"%(user_info[uid], movie_info[mov_id], train_sample[-1])
  1. User <UserInfo id(1), gender(F), age(1), job(10)> rates Movie <MovieInfo id(1193), title(One Flew Over the Cuckoo's Nest ), categories(['Drama'])> with Score [5.0]

即用户1对电影1193的评价为5分。

模型配置说明

下面我们开始根据输入数据的形式配置模型。首先引入所需的库函数以及定义全局变量。- IS_SPARSE: embedding中是否使用稀疏更新- PASS_NUM: epoch数量

  1. from __future__ import print_function
  2. import math
  3. import sys
  4. import numpy as np
  5. import paddle
  6. import paddle.fluid as fluid
  7. import paddle.fluid.layers as layers
  8. import paddle.fluid.nets as nets
  9.  
  10. IS_SPARSE = True
  11. BATCH_SIZE = 256
  12. PASS_NUM = 20

然后为我们的用户特征综合模型定义模型配置

  1. def get_usr_combined_features():
  2.     """network definition for user part"""
  3.  
  4.     USR_DICT_SIZE = paddle.dataset.movielens.max_user_id() + 1
  5.  
  6.     uid = layers.data(name='user_id', shape=[1], dtype='int64')
  7.  
  8.     usr_emb = layers.embedding(
  9.         input=uid,
  10.         dtype='float32',
  11.         size=[USR_DICT_SIZE, 32],
  12.         param_attr='user_table',
  13.         is_sparse=IS_SPARSE)
  14.  
  15.     usr_fc = layers.fc(input=usr_emb, size=32)
  16.  
  17.     USR_GENDER_DICT_SIZE = 2
  18.  
  19.     usr_gender_id = layers.data(name='gender_id', shape=[1], dtype='int64')
  20.  
  21.     usr_gender_emb = layers.embedding(
  22.         input=usr_gender_id,
  23.         size=[USR_GENDER_DICT_SIZE, 16],
  24.         param_attr='gender_table',
  25.         is_sparse=IS_SPARSE)
  26.  
  27.     usr_gender_fc = layers.fc(input=usr_gender_emb, size=16)
  28.  
  29.     USR_AGE_DICT_SIZE = len(paddle.dataset.movielens.age_table)
  30.     usr_age_id = layers.data(name='age_id', shape=[1], dtype="int64")
  31.  
  32.     usr_age_emb = layers.embedding(
  33.         input=usr_age_id,
  34.         size=[USR_AGE_DICT_SIZE, 16],
  35.         is_sparse=IS_SPARSE,
  36.         param_attr='age_table')
  37.  
  38.     usr_age_fc = layers.fc(input=usr_age_emb, size=16)
  39.  
  40.     USR_JOB_DICT_SIZE = paddle.dataset.movielens.max_job_id() + 1
  41.     usr_job_id = layers.data(name='job_id', shape=[1], dtype="int64")
  42.  
  43.     usr_job_emb = layers.embedding(
  44.         input=usr_job_id,
  45.         size=[USR_JOB_DICT_SIZE, 16],
  46.         param_attr='job_table',
  47.         is_sparse=IS_SPARSE)
  48.  
  49.     usr_job_fc = layers.fc(input=usr_job_emb, size=16)
  50.  
  51.     concat_embed = layers.concat(
  52.         input=[usr_fc, usr_gender_fc, usr_age_fc, usr_job_fc], axis=1)
  53.  
  54.     usr_combined_features = layers.fc(input=concat_embed, size=200, act="tanh")
  55.  
  56.     return usr_combined_features

如上述代码所示，对于每个用户，我们输入4维特征。其中包括user_id,gender_id,age_id,job_id。这几维特征均是简单的整数值。为了后续神经网络处理这些特征方便，我们借鉴NLP中的语言模型，将这几维离散的整数值，变换成embedding取出。分别形成usr_emb, usr_gender_emb, usr_age_emb, usr_job_emb。

然后，我们对于所有的用户特征，均输入到一个全连接层(fc)中。将所有特征融合为一个200维度的特征。

进而，我们对每一个电影特征做类似的变换，网络配置为:

  1. def get_mov_combined_features():
  2.     """network definition for item(movie) part"""
  3.  
  4.     MOV_DICT_SIZE = paddle.dataset.movielens.max_movie_id() + 1
  5.  
  6.     mov_id = layers.data(name='movie_id', shape=[1], dtype='int64')
  7.  
  8.     mov_emb = layers.embedding(
  9.         input=mov_id,
  10.         dtype='float32',
  11.         size=[MOV_DICT_SIZE, 32],
  12.         param_attr='movie_table',
  13.         is_sparse=IS_SPARSE)
  14.  
  15.     mov_fc = layers.fc(input=mov_emb, size=32)
  16.  
  17.     CATEGORY_DICT_SIZE = len(paddle.dataset.movielens.movie_categories())
  18.  
  19.     category_id = layers.data(
  20.         name='category_id', shape=[1], dtype='int64', lod_level=1)
  21.  
  22.     mov_categories_emb = layers.embedding(
  23.         input=category_id, size=[CATEGORY_DICT_SIZE, 32], is_sparse=IS_SPARSE)
  24.  
  25.     mov_categories_hidden = layers.sequence_pool(
  26.         input=mov_categories_emb, pool_type="sum")
  27.  
  28.     MOV_TITLE_DICT_SIZE = len(paddle.dataset.movielens.get_movie_title_dict())
  29.  
  30.     mov_title_id = layers.data(
  31.         name='movie_title', shape=[1], dtype='int64', lod_level=1)
  32.  
  33.     mov_title_emb = layers.embedding(
  34.         input=mov_title_id, size=[MOV_TITLE_DICT_SIZE, 32], is_sparse=IS_SPARSE)
  35.  
  36.     mov_title_conv = nets.sequence_conv_pool(
  37.         input=mov_title_emb,
  38.         num_filters=32,
  39.         filter_size=3,
  40.         act="tanh",
  41.         pool_type="sum")
  42.  
  43.     concat_embed = layers.concat(
  44.         input=[mov_fc, mov_categories_hidden, mov_title_conv], axis=1)
  45.  
  46.     mov_combined_features = layers.fc(input=concat_embed, size=200, act="tanh")
  47.  
  48.     return mov_combined_features

电影标题名称(title)是一个序列的整数，整数代表的是这个词在索引序列中的下标。这个序列会被送入 sequence_conv_pool 层，这个层会在时间维度上使用卷积和池化。因为如此，所以输出会是固定长度，尽管输入的序列长度各不相同。

最后，我们定义一个inference_program来使用余弦相似度计算用户特征与电影特征的相似性。

  1. def inference_program():
  2.     """the combined network"""
  3.  
  4.     usr_combined_features = get_usr_combined_features()
  5.     mov_combined_features = get_mov_combined_features()
  6.  
  7.     inference = layers.cos_sim(X=usr_combined_features, Y=mov_combined_features)
  8.     scale_infer = layers.scale(x=inference, scale=5.0)
  9.  
  10.     return scale_infer

进而，我们定义一个train_program来使用inference_program计算出的结果，在标记数据的帮助下来计算误差。我们还定义了一个optimizer_func来定义优化器。

  1. def train_program():
  2.     """define the cost function"""
  3.  
  4.     scale_infer = inference_program()
  5.  
  6.     label = layers.data(name='score', shape=[1], dtype='float32')
  7.     square_cost = layers.square_error_cost(input=scale_infer, label=label)
  8.     avg_cost = layers.mean(square_cost)
  9.  
  10.     return [avg_cost, scale_infer]
  11.  
  12.  
  13. def optimizer_func():
  14.     return fluid.optimizer.SGD(learning_rate=0.2)

训练模型

定义训练环境

定义您的训练环境，可以指定训练是发生在CPU还是GPU上。

  1. use_cuda = False
  2. place = fluid.CUDAPlace(0) if use_cuda else fluid.CPUPlace()

定义数据提供器

下一步是为训练和测试定义数据提供器。提供器读入一个大小为 BATCH_SIZE的数据。paddle.dataset.movielens.train 每次会在乱序化后提供一个大小为BATCH_SIZE的数据，乱序化的大小为缓存大小buf_size。

  1. train_reader = paddle.batch(
  2.     paddle.reader.shuffle(
  3.         paddle.dataset.movielens.train(), buf_size=8192),
  4.     batch_size=BATCH_SIZE)
  5.  
  6. test_reader = paddle.batch(
  7.     paddle.dataset.movielens.test(), batch_size=BATCH_SIZE)

构造训练过程(trainer)

我们这里构造了一个训练过程，包括训练优化函数。

提供数据

feed_order用来定义每条产生的数据和paddle.layer.data之间的映射关系。比如，movielens.train产生的第一列的数据对应的是user_id这个特征。

  1. feed_order = [
  2.     'user_id', 'gender_id', 'age_id', 'job_id', 'movie_id', 'category_id',
  3.     'movie_title', 'score'
  4. ]

构建训练程序以及测试程序

分别构建训练程序和测试程序，并引入训练优化器。

  1. main_program = fluid.default_main_program()
  2. star_program = fluid.default_startup_program()
  3. [avg_cost, scale_infer] = train_program()
  4.  
  5. test_program = main_program.clone(for_test=True)
  6. sgd_optimizer = optimizer_func()
  7. sgd_optimizer.minimize(avg_cost)
  8. exe = fluid.Executor(place)
  9.  
  10. def train_test(program, reader):
  11.     count = 0
  12.     feed_var_list = [
  13.         program.global_block().var(var_name) for var_name in feed_order
  14.     ]
  15.     feeder_test = fluid.DataFeeder(
  16.     feed_list=feed_var_list, place=place)
  17.     test_exe = fluid.Executor(place)
  18.     accumulated = 0
  19.     for test_data in reader():
  20.         avg_cost_np = test_exe.run(program=program,
  21.                                                feed=feeder_test.feed(test_data),
  22.                                                fetch_list=[avg_cost])
  23.         accumulated += avg_cost_np[0]
  24.         count += 1
  25.     return accumulated / count

构建训练主循环并开始训练

我们根据上面定义的训练循环数（PASS_NUM）和一些别的参数，来进行训练循环，并且每次循环都进行一次测试，当测试结果足够好时退出训练并保存训练好的参数。

  1. # Specify the directory path to save the parameters
  2. params_dirname = "recommender_system.inference.model"
  3.  
  4. from paddle.utils.plot import Ploter
  5. train_prompt = "Train cost"
  6. test_prompt = "Test cost"
  7.  
  8. plot_cost = Ploter(train_prompt, test_prompt)
  9.  
  10. def train_loop():
  11.     feed_list = [
  12.         main_program.global_block().var(var_name) for var_name in feed_order
  13.     ]
  14.     feeder = fluid.DataFeeder(feed_list, place)
  15.     exe.run(star_program)
  16.  
  17.     for pass_id in range(PASS_NUM):
  18.         for batch_id, data in enumerate(train_reader()):
  19.             # train a mini-batch
  20.             outs = exe.run(program=main_program,
  21.                                feed=feeder.feed(data),
  22.                                fetch_list=[avg_cost])
  23.             out = np.array(outs[0])
  24.  
  25.             # get test avg_cost
  26.             test_avg_cost = train_test(test_program, test_reader)
  27.  
  28.             plot_cost.append(train_prompt, batch_id, outs[0])
  29.             plot_cost.append(test_prompt, batch_id, test_avg_cost)
  30.             plot_cost.plot()
  31.  
  32.             if batch_id == 20:
  33.                 if params_dirname is not None:
  34.                     fluid.io.save_inference_model(params_dirname, [
  35.                                 "user_id", "gender_id", "age_id", "job_id",
  36.                                 "movie_id", "category_id", "movie_title"
  37.                         ], [scale_infer], exe)
  38.                 return
  39.             print('EpochID {0}, BatchID {1}, Test Loss {2:0.2}'.format(
  40.                             pass_id + 1, batch_id + 1, float(test_avg_cost)))
  41.  
  42.             if math.isnan(float(out[0])):
  43.                 sys.exit("got NaN loss, training failed.")

开始训练

  1. train_loop()

应用模型

生成测试数据

使用 create_lod_tensor(data, lod, place) 的API来生成细节层次的张量。data是一个序列，每个元素是一个索引号的序列。lod是细节层次的信息，对应于data。比如，data = [[10, 2, 3], [2, 3]] 意味着它包含两个序列，长度分别是3和2。于是相应地 lod = [[3, 2]]，它表明其包含一层细节信息，意味着 data 有两个序列，长度分别是3和2。

在这个预测例子中，我们试着预测用户ID为1的用户对于电影'Hunchback of Notre Dame'的评分

  1. infer_movie_id = 783
  2. infer_movie_name = paddle.dataset.movielens.movie_info()[infer_movie_id].title
  3. user_id = fluid.create_lod_tensor([[1]], [[1]], place)
  4. gender_id = fluid.create_lod_tensor([[1]], [[1]], place)
  5. age_id = fluid.create_lod_tensor([[0]], [[1]], place)
  6. job_id = fluid.create_lod_tensor([[10]], [[1]], place)
  7. movie_id = fluid.create_lod_tensor([[783]], [[1]], place) # Hunchback of Notre Dame
  8. category_id = fluid.create_lod_tensor([[10, 8, 9]], [[3]], place) # Animation, Children's, Musical
  9. movie_title = fluid.create_lod_tensor([[1069, 4140, 2923, 710, 988]], [[5]],
  10.                                       place) # 'hunchback','of','notre','dame','the'

构建预测过程并测试

与训练过程类似，我们需要构建一个预测过程。其中， params_dirname是之前用来存放训练过程中的各个参数的地址。

  1. place = fluid.CUDAPlace(0) if use_cuda else fluid.CPUPlace()
  2. exe = fluid.Executor(place)
  3.  
  4. inference_scope = fluid.core.Scope()

测试

现在我们可以进行预测了。我们要提供的feed_order应该和训练过程一致。

  1. with fluid.scope_guard(inference_scope):
  2.     [inferencer, feed_target_names,
  3.     fetch_targets] = fluid.io.load_inference_model(params_dirname, exe)
  4.  
  5.     results = exe.run(inferencer,
  6.                           feed={
  7.                                'user_id': user_id,
  8.                               'gender_id': gender_id,
  9.                               'age_id': age_id,
  10.                               'job_id': job_id,
  11.                               'movie_id': movie_id,
  12.                               'category_id': category_id,
  13.                               'movie_title': movie_title
  14.                           },
  15.                           fetch_list=fetch_targets,
  16.                           return_numpy=False)
  17.     predict_rating = np.array(results[0])
  18.     print("Predict Rating of user id 1 on movie \"" + infer_movie_name +
  19.               "\" is " + str(predict_rating[0][0]))
  20.     print("Actual Rating of user id 1 on movie \"" + infer_movie_name +
  21.               "\" is 4.")

总结

本章介绍了传统的个性化推荐系统方法和YouTube的深度神经网络个性化推荐系统，并以电影推荐为例，使用PaddlePaddle训练了一个个性化推荐神经网络模型。个性化推荐系统几乎涵盖了电商系统、社交网络、广告推荐、搜索引擎等领域的方方面面，而在图像处理、自然语言处理等领域已经发挥重要作用的深度学习技术，也将会在个性化推荐系统领域大放异彩。

参考文献