预测电影偏好？如何利用自编码器实现协同过滤方法

推荐系统使用协同过滤的方法，通过收集用户的偏好信息来预测特定用户的兴趣。协同过滤技术的基本假设是，如果用户 A 对某个问题与人 B 有相同的口味或意见，那么 A 就更有可能在其他问题上拥有与 B 的相同的意见。

本文将介绍如何根据用户的偏好、观看历史、相同评级和其他电影的其他用户的评价预测用户对电影的评分。

一、介绍

自动编码器是一种深度学习神经网络架构，可实现协同过滤领域最佳的性能。文章的第一部是理论概述，将会介绍简单的自动编码器及深度自编码器的基础数学概念。在第二部分中，我们将深入实际展示如何在 TensorFlow 中逐步应用这一技术。本文仅覆盖和评价模型中最重要的部分。

整个模型的输入渠道和预处理可以在相应的 GitHub 中查看：

https://github.com/artem-oppermann/Deep-Autoencoders-For-Collaborative-Filtering

二、深度自编码器

1. 自编码器

讨论深度自编码器之前，我们先来介绍它稍微简单些的版本。自编码器(Autoencoder)是一种人工神经网络，用于学习一组输入数据的表示(编码)，通常用于实现降维。

在结构上，自编码器的形式是一个前馈神经网络，由输入层、一个隐藏层和一个输出层(图 1)构成。输出层与输入层的神经元数量相同，因此自编码器属于无监督学习，这意味着它不需要标记数据——只需要一组输入数据即可，而不是输入—输出对。

图 1. 典型的 AutoEncoder 架构

自编码器的隐藏层比输入层小，这使得模型可以通过学习数据中的相关性在隐藏层中创建数据的压缩表示。

输入层到隐藏层的转换被称为编码步骤，从隐藏层到输出层的转换称为解码步骤。我们也可以在数学上将这些转换定义为映射：

该映射是通过将输入数据向量乘以权重矩阵，添加一个偏差项并将所得到的向量应用于非线性运算，如 sigmoid，tanh 或整流线性单元来实现的。

2. 自编码器的训练

在训练期间，编码器接收输入数据样本 x 并将其映射到所谓的隐藏层或隐层表示 z 上。然后解码器将 z 映射到输出向量 x' 上，后者是(在最好的情况下)输入数据 x 的准确表示。需要注意的是，通常情况下准确地重建 x 是不可能的。

具有输出 x' 的训练包括应用随机梯度下降以最小化预定损失，例如均方误差：

3. 深度自编码器

简单自动编码器的扩展版是 Deep Autoencoder(图 2)。从图 2 中可以看出，它与简单的计数器部分唯一的区别在于隐藏层的数量。

图 2. 深度自编码器的架构

额外的隐藏层使自编码器可以从数学上学习数据中更复杂的底层模式。深度自编码器的第一层可以学习原始输入中的一阶特征(例如图像中的边缘)。第二层可以学习对应于一阶特征的外观中的图案的二阶特征(例如，根据哪些边缘倾向于一起发生——例如以形成轮廓或角检测器)。深度自编码器更深层的特性往往可以学习到更高阶的特性。

把所有东西放在一起：我们需要更多的层来处理更为复杂的数据——比如我们在协作过滤中使用的数据。

三、实现

如前文所述，你将学会预测用户对电影的评级。就此而言，我们将使用著名的 MovieLens 数据集

(https://grouplens.org/datasets/movielens/)。MovieLensis 是一个基于网络的推荐系统和推荐用户观看电影的在线社区。

更具体地说，我们将使用 ml_1m.zip 数据集，该数据集包含 6,040 个 MovieLens 用户制作的，约 3,900 部电影的 1,000,209 个匿名评级。我们需要的导入文件是 ratings.dat。该文件包含 1,000,209 行，全部格式如下：user_id :: movie_id :: rating：time_stamp。

例如 ratings.dat 中的第一行：

 
 
 
 
    
  
  
  
  
  1. 1::595::5::978824268   
    2.

这意味着用户 1 给了 595 号电影打了五星评分。评分时间可以被忽略，因为在这里我们不会使用它。

我们的深度学习模型需要一个特定的数据结构来进行训练和测试。这种数据结构是一个 UxM 矩阵，其中 U 是用户数量，M 是电影数量。每行 i∈U 是唯一的用户 ID，每列 j∈M 是唯一的电影 ID。这种矩阵的可视化效果如图 3 所示。

此矩阵中的每个条目都是用户给出特定电影的评分。输入 0 意味着用户没有给这部电影任何评价。例如。上图中，1 号用户给电影 3 的评级为四星，而电影第 1 则根本没有评级。

由于本教程将重点介绍深度学习模型的实现，因此不会在这里介绍使用 User-Movie-Matrix 超出 ratings.dat 文件的步骤。对于关于这个主题的进一步问题，你可以去我的 GitHub 页面

(https://github.com/artem-oppermann/Deep-Autoencoders-For-Collaborative-Filtering/blob/master/data/preprocess_data.py)， 查看相应的 python 脚本。

1. 训练和测试数据集

在模型实现和训练之前，我们需要对数据进行其他重新处理步骤，将数据划分为训练和测试数据集。这一步骤简单明了。到目前为止，我们有一个 User-Movie Matrix，其中每一行都是评级列表。要从列表中获得训练和测试集，我们需要从每一行中取一部分评级，并将它们用于训练，其余子集则用于测试。

作为描述过程的一个例子，我们考虑一个仅包含 15 部电影的小得多的数据集。一个特定的用户可能出给这样的电影评级：

 
 
 
 
    
  
  
  
  
  1. Movie Nr. : 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 
    2. 
  
  
  
  
  2. Rating:     5 0 2 4 0 0 2 1 5  1  0  4  5  1  3 
    3.

请记住，0 表示该电影未被评级。现在我们将前 10 部电影中的一部分作为训练集并假设其余的还没有被评分：

 
 
 
 
    
  
  
  
  
  1. Movie Nr. : 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 
    2. 
  
  
  
  
  2. Rating:     5 0 2 4 0 0 2 1 5  0  0  0  0  0  0 
    3.

因此，原始数据的最后 5 个电影等级被用作测试数据，而电影 1-10 被掩盖为未被评级：

 
 
 
 
    
  
  
  
  
  1. Movie Nr. : 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 
    2. 
  
  
  
  
  2. Rating:     0 0 0 0 0 0 0 0 0  1  0  4  5  1  3 
    3.

此处仅仅简单演示了如何获得不同的组合。在原始的 MovieLens 数据集中，我仅使用每个用户的 10 个电影评级进行测试，其余(绝大多数)用于模型的训练。

2. TensorFlow 实现

(1) 模型架构

深度自编码器在这里作为一个类来实现，其中包含所有必需的操作，如类内的推理、优化、损失、准确性等。

在构造器中，内核初始化器设置了权重和偏差。下一步，网络中的所有权重和偏差都会被初始化。权重是遵从正态分布的，平均值为 0.0，方差为 0.02，而偏差在开始时都设置为 0.0。

在这个特定的例子中，网络有三个隐藏层，每层包含 128 个神经元。输入层(和输出层)的大小对应于数据集中所有当前影片的数量。

 
 
 
 
    
  
  
  
  
  1. class DAE: 
    2. 
  
  
  
  
  2.     ''' Implementation of Deep Autoencoder class''' 
    3. 
  
  
  
  
  3.  
    4. 
  
  
  
  
  4.     def __init__(self, FLAGS):     
    5. 
  
  
  
  
  5.         self.FLAGS=FLAGS 
    6. 
  
  
  
  
  6.         self.weight_initializer=model_helper._get_weight_initializer() 
    7. 
  
  
  
  
  7.         self.bias_initializer=model_helper._get_bias_initializer() 
    8. 
  
  
  
  
  8.         self.init_parameters() 
    9. 
  
  
  
  
  9.  
    10. 
  
  
  
  
  10.  
    11. 
  
  
  
  
  11.     def init_parameters(self): 
    12. 
  
  
  
  
  12.         ''' Initializing the weights and biasis of the neural network.''' 
    13. 
  
  
  
  
  13.  
    14. 
  
  
  
  
  14.         with tf.name_scope('weights'): 
    15. 
  
  
  
  
  15.             self.W_1=tf.get_variable(name='weight_1', shape=(self.FLAGS.num_v,self.FLAGS.num_h),  
    16. 
  
  
  
  
  16.                                      initializer=self.weight_initializer) 
    17. 
  
  
  
  
  17.             self.W_2=tf.get_variable(name='weight_2', shape=(self.FLAGS.num_h,self.FLAGS.num_h),  
    18. 
  
  
  
  
  18.                                      initializer=self.weight_initializer) 
    19. 
  
  
  
  
  19.             self.W_3=tf.get_variable(name='weight_3', shape=(self.FLAGS.num_h,self.FLAGS.num_h),  
    20. 
  
  
  
  
  20.                                      initializer=self.weight_initializer) 
    21. 
  
  
  
  
  21.             self.W_4=tf.get_variable(name='weight_5', shape=(self.FLAGS.num_h,self.FLAGS.num_v),  
    22. 
  
  
  
  
  22.                                      initializer=self.weight_initializer) 
    23. 
  
  
  
  
  23.  
    24. 
  
  
  
  
  24.         with tf.name_scope('biases'): 
    25. 
  
  
  
  
  25.             self.b1=tf.get_variable(name='bias_1', shape=(self.FLAGS.num_h),  
    26. 
  
  
  
  
  26.                                     initializer=self.bias_initializer) 
    27. 
  
  
  
  
  27.             self.b2=tf.get_variable(name='bias_2', shape=(self.FLAGS.num_h),  
    28. 
  
  
  
  
  28.                                     initializer=self.bias_initializer) 
    29. 
  
  
  
  
  29.             self.b3=tf.get_variable(name='bias_3', shape=(self.FLAGS.num_h),  
    30. 
  
  
  
  
  30.                                     initializer=self.bias_initializer) 
    31.

(2) 训练

给定一个输入数据样本 x(用户—电影矩阵的一行)，正向传递并计算网络输出。隐藏层使用 sigmoid 作为激活函数。请注意，最后一层没有非线性或偏置项。

 
 
 
 
    
  
  
  
  
  1. def _inference(self, x): 
    2. 
  
  
  
  
  2.     '''Making one forward pass. Predicting the outputs, given the inputs.''' 
    3. 
  
  
  
  
  3.  
    4. 
  
  
  
  
  4.     with tf.name_scope('inference'): 
    5. 
  
  
  
  
  5.          a1=tf.nn.sigmoid(tf.nn.bias_add(tf.matmul(x, self.W_1),self.b1)) 
    6. 
  
  
  
  
  6.          a2=tf.nn.sigmoid(tf.nn.bias_add(tf.matmul(a1, self.W_2),self.b2)) 
    7. 
  
  
  
  
  7.          a3=tf.nn.sigmoid(tf.nn.bias_add(tf.matmul(a2, self.W_3),self.b3))    
    8. 
  
  
  
  
  8.          a4=tf.matmul(a3, self.W_4)  
    9. 
  
  
  
  
  9.     return a4 
    10.

通过网络预测，我们可以计算这些预测与相应标签(网络输入 x)之间的损失。为了计算损失的平均值，我们还需要知道非零标签的数量——也就是训练集中用户的总评分数。

 
 
 
 
    
  
  
  
  
  1. def _compute_loss(self, predictions, labels,num_labels): 
    2. 
  
  
  
  
  2.    ''' Computing the Mean Squared Error loss between the input and output of the network. 
    3. 
  
  
  
  
  3.  
    4. 
  
  
  
  
  4.     @param predictions: predictions of the stacked autoencoder 
    5. 
  
  
  
  
  5.     @param labels: input values of the stacked autoencoder which serve as labels at the same time 
    6. 
  
  
  
  
  6.     @param num_labels: number of labels !=0 in the data set to compute the mean 
    7. 
  
  
  
  
  7.  
    8. 
  
  
  
  
  8.     @return mean squared error loss tf-operation 
    9. 
  
  
  
  
  9.     ''' 
    10. 
  
  
  
  
  10.          with tf.name_scope('loss'): 
    11. 
  
  
  
  
  11.          loss_op=tf.div(tf.reduce_sum(tf.square(tf.subtract(predictions,labels))),num_labels) 
    12. 
  
  
  
  
  12.          return loss_op 
    13.

网络的优化/训练步骤似乎有点棘手，让我们一步一步讨论。给定输入 x，计算相应的输出。你可能已经注意到，输入 x 中的大部分值都是零值，因为用户肯定没有观看和评估数据集中的所有 5953 部电影。因此，建议不要直接使用网络的原始预测。相反，我们必须确定数据输入 x 中零值的索引，并将与这些索引相对应的预测向量中的值也设置为零。这种预测操纵极大地减少了网络的训练时间，使网络有机会将训练努力集中在用户实际给出的评分上。

在此步骤之后，可以计算损失以及正则化损失(可选)。AdamOptimizer 会将损失函数最小化。请注意，该方法会返回一个均方根误差(RMSE)而不是均方误差(MSE)，以测得更好的精度。

 
 
 
 
    
  
  
  
  
  1. def _optimizer(self, x): 
    2. 
  
  
  
  
  2.         '''Optimization of the network parameter through stochastic gradient descent. 
    3. 
  
  
  
  
  3.  
    4. 
  
  
  
  
  4.             @param x: input values for the stacked autoencoder. 
    5. 
  
  
  
  
  5.  
    6. 
  
  
  
  
  6.             @return: tensorflow training operation 
    7. 
  
  
  
  
  7.             @return: ROOT!! mean squared error 
    8. 
  
  
  
  
  8.         ''' 
    9. 
  
  
  
  
  9.  
    10. 
  
  
  
  
  10.         outputs=self._inference(x) 
    11. 
  
  
  
  
  11.         mask=tf.where(tf.equal(x,0.0), tf.zeros_like(x), x) # indices of zero values in the training set (no ratings) 
    12. 
  
  
  
  
  12.         num_train_labels=tf.cast(tf.count_nonzero(mask),dtype=tf.float32) # number of non zero values in the training set 
    13. 
  
  
  
  
  13.         bool_mask=tf.cast(mask,dtype=tf.bool) # boolean mask 
    14. 
  
  
  
  
  14.         outputs=tf.where(bool_mask, outputs, tf.zeros_like(outputs)) # set the output values to zero if corresponding input values are zero 
    15. 
  
  
  
  
  15.  
    16. 
  
  
  
  
  16.         MSE_loss=self._compute_loss(outputs,x,num_train_labels) 
    17. 
  
  
  
  
  17.  
    18. 
  
  
  
  
  18.         if self.FLAGS.l2_reg==True: 
    19. 
  
  
  
  
  19.             l2_loss = tf.add_n([tf.nn.l2_loss(v) for v in tf.trainable_variables()]) 
    20. 
  
  
  
  
  20.             MSE_lossMSE_loss = MSE_loss +  self.FLAGS.lambda_ * l2_loss 
    21. 
  
  
  
  
  21.  
    22. 
  
  
  
  
  22.         train_op=tf.train.AdamOptimizer(self.FLAGS.learning_rate).minimize(MSE_loss) 
    23. 
  
  
  
  
  23.         RMSE_loss=tf.sqrt(MSE_loss) 
    24. 
  
  
  
  
  24.  
    25. 
  
  
  
  
  25.         return train_op, RMSE_loss 
    26.

(3) 测试

训练几个 epoch 之后，神经网络已经在训练集中看到每个用户的所有评分以及时间了。此时该模型应该已经了解数据中潜在的隐藏模式以及用户对应的电影评级规律。给定用户评分训练样本 x，该模型预测输出 x'。该向量由输入值 x 的重构(如预期)组成，但现在还包含输入 x 中先前为零的值。这意味着该模型在给未评分的电影打分。这个评级对应于用户的偏好——模型从数据中已识别和学习到的偏好。

为了能够测量模型的准确性，我们需要训练和测试数据集。根据训练集进行预测。类似于训练阶段，我们只考虑对应于测试集中非零值的索引的输出值。

现在我们可以计算预测值与实际评分之间的均方根误差损失(RMSE)。RMSE 表示预测值与观测值之间差异的样本标准偏差。例如，RMSE 为 0.5 意味着平均预测评分与实际评分相差 0.5 星。

 
 
 
 
    
  
  
  
  
  1. def _validation_loss(self, x_train, x_test): 
    2. 
  
  
  
  
  2.         ''' Computing the loss during the validation time. 
    3. 
  
  
  
  
  3.         @param x_train: training data samples 
    4. 
  
  
  
  
  4.         @param x_test: test data samples 
    5. 
  
  
  
  
  5.         @return networks predictions 
    6. 
  
  
  
  
  6.         @return root mean squared error loss between the predicted and actual ratings 
    7. 
  
  
  
  
  7.         ''' 
    8. 
  
  
  
  
  8.         outputs=self._inference(x_train) # use training sample to make prediction 
    9. 
  
  
  
  
  9.         mask=tf.where(tf.equal(x_test,0.0), tf.zeros_like(x_test), x_test) # identify the zero values in the test ste 
    10. 
  
  
  
  
  10.         num_test_labels=tf.cast(tf.count_nonzero(mask),dtype=tf.float32) # count the number of non zero values 
    11. 
  
  
  
  
  11.         bool_mask=tf.cast(mask,dtype=tf.bool)  
    12. 
  
  
  
  
  12.         outputs=tf.where(bool_mask, outputs, tf.zeros_like(outputs)) 
    13. 
  
  
  
  
  13.  
    14. 
  
  
  
  
  14.         MSE_loss=self._compute_loss(outputs, x_test, num_test_labels) 
    15. 
  
  
  
  
  15.         RMSE_loss=tf.sqrt(MSE_loss) 
    16. 
  
  
  
  
  16.  
    17. 
  
  
  
  
  17.         return outputs, RMSE_loss 
    18.

(4) 训练结果

最后一步包括执行训练过程并检查模型性能。在这一点上，我不会详细讨论构建数据输入管道、图表、会话等细节。因为这些步骤通常是已知的。对此主题感兴趣的读者可以在我的 GitHub 中查看这些步骤：https://github.com/artem-oppermann/Deep-Autoencoders-For-Collaborative-Filtering/blob/master/train.py

在这里，你可以看到前 50 个迭代次数的训练和测试表现。50 次后，测试集的预测和实际评分间的偏差是 0.929 星。

 
 
 
 
    
  
  
  
  
  1. epoch_nr: 0, train_loss: 1.169, test_loss: 1.020 
    2. 
  
  
  
  
  2. epoch_nr: 10, train_loss: 0.936, test_loss: 0.959  
    3. 
  
  
  
  
  3. epoch_nr: 20, train_loss: 0.889, test_loss: 0.931  
    4. 
  
  
  
  
  4. epoch_nr: 30, train_loss: 0.873, test_loss: 0.923  
    5. 
  
  
  
  
  5. epoch_nr: 40, train_loss: 0.859, test_loss: 0.925  
    6. 
  
  
  
  
  6. epoch_nr: 50, train_loss: 0.844, test_loss: 0.929 
    7.

原文地址：

https://towardsdatascience.com/deep-autoencoders-for-collaborative-filtering-6cf8d25bbf1d

【本文是专栏机构“机器之心”的原创译文，微信公众号“机器之心( id: almosthuman2014)”】

网页题目：预测电影偏好？如何利用自编码器实现协同过滤方法
网页URL：http://www.shufengxianlan.com/qtweb/news5/352705.html

网站建设、网络推广公司-创新互联，是专注品牌与效果的网站制作，网络营销seo公司；服务项目有等

广告

声明：本网站发布的内容（图片、视频和文字）以用户投稿、用户转载内容为主，如果涉及侵权请尽快告知，我们将会在第一时间删除。文章观点不代表本网站立场，如需处理请联系客服。电话：028-86922220；邮箱：631063699@qq.com。内容未经允许不得转载，或转载时需注明来源： 创新互联

猜你还喜欢下面的内容

品牌网站制作知识

行业网站建设

圣月阀门　　 　四川平武网站建设　　 　成都雪糕加盟　　 　小程序开发　　 　网站SEO优化　　 　成都网络推广　　 　乐山电信机房　　 　微信开发　　 　成都包装设计公司　　 　平昌做网站　　 　电信内江机房　　 　德阳服务器托管　　 　资阳服务器托管　　 　复盛机电设备　　 　什邡网站建设　　 　泸州洋跃建站　　 　古巴雪茄　　 　响应式网站设计　　 　微信网站开发　　 　蜜朵婚庆