推荐系统-AutoRec 的推荐系统介绍与python实现

最新推荐文章于 2024-04-26 16:51:33 发布

JohnBanana

最新推荐文章于 2024-04-26 16:51:33 发布

阅读量1.6k

点赞数 1

分类专栏：推荐系统文章标签：深度学习推荐系统 python 神经网络

本文链接：https://blog.csdn.net/john_hongming/article/details/106565025

版权

推荐系统专栏收录该内容

11 篇文章 6 订阅

订阅专栏

本文要介绍的模型是2015年由澳大利亚国立大学提出的AutoRec。它将自编码器（AutoEncoder）的思想和协同过滤结合，提出了一种但隐藏层的神经网络推荐model。因为简洁的网络结构和清晰易懂的模型原理，所以非常适合深度学习的推荐model 的入门模型来学习

本文参考了王喆大佬的新书，《深度学习推荐系统》

论文地址

1.引言

协同过滤模型的目的是利用用户对商品的偏好信息来提供个性化的推荐。AutoRec是一个新型的基于自动编码器的协同过滤模型。论文作者认为AutoRec与现有的将玻尔兹曼机用于协同过滤的神经方法相比具有表征和计算上的优势，并从经验上证明了AutoRec优于当前最先进的方法

2.自编码器模型

在基于评分的协同过滤中，假设有m个用户，n个物品，并且有一个用户-物品的评分矩阵 $R\in \mathbb{R}^{}m^\times ^n$ 。每个用户向量u∈U={1.....m}可以被向量 $r^{}(^u^) = (R_{}u_{}1,...R_{}u_{}n) \in \mathbb{R}^n$ 表示

3.AutoRec模型的结构

下图为AutoRec的结构图，从图中可以看出，网络的输入层是物品的评分向量r,输出层是一个多分类层、蓝色的神经元代表模型的k维单隐层，其中k<<m。

AutoRec模型的结构图

以上介绍的AutoRec输入向量是物品的评分向量，因此可称为I-AutoRec(Item based AutoRec).

4.推荐过程

基于AutoRec 模型的推荐过程并不复杂，当输入物品i 的评分向量为 $r^(^i^)$ 时，模型输出向量 $h(r^(^i^);\theta)$

就是所有用户对物品i 的评分预测。那么。其中的第 u 维就是用户对物品i 的预测 $\widehat{R}_{u}_{i}$ =

$h((r^(^i^);\widehat{}\theta))_{}u$ 。

之后通过遍历输入物品向量就可以得到用户 u 对所有物品的评分预测，进而根据评分预测排序得到推荐列表。

与 CF 一样 AutoRec 也分为 U - AutoRec 和 I - AutoRec

5.AutoRec模型的特点和局限性

AutoRec模型使用一个单隐层的AutoEncoder泛化用户或物品评分，使模型具有一定的泛化和表达能力。由于AutoRec模型的结构比较简单，使其存在一定的表达能力不足的问题。

从深度学习的角度来说，AutoRec模型的提出，拉开了使用深度学习的思想解决推荐问题的序幕，为复杂深度学习网络的构建提供了思路。

6.基于ml-1m 数据集测试

data 处理部分

import numpy as np
import argparse
import math


def get_data(path, num_users, num_items, num_total_ratings, train_ratio):
    fp = open(path + "ratings.dat")

    user_train_set = set()
    user_test_set = set()
    item_train_set = set()
    item_test_set = set()

    train_r = np.zeros((num_users, num_items))
    test_r = np.zeros((num_users, num_items))

    train_mask_r = np.zeros((num_users, num_items))
    test_mask_r = np.zeros((num_users, num_items))

    random_perm_idx = np.random.permutation(num_total_ratings)
    train_idx = random_perm_idx[0:int(num_total_ratings * train_ratio)]
    test_idx = random_perm_idx[int(num_total_ratings * train_ratio):]

    lines = fp.readlines()


    for itr in train_idx:
        line = lines[itr]
        user, item, rating, _ = line.split("::")
        user_idx = int(user) - 1
        item_idx = int(item) - 1
        train_r[user_idx, item_idx] = int(rating)
        train_mask_r[user_idx, item_idx] = 1

        user_train_set.add(user_idx)
        item_train_set.add(item_idx)


    for itr in test_idx:
        line = lines[itr]
        user, item, rating, _ = line.split("::")
        user_idx = int(user) - 1
        item_idx = int(item) - 1
        test_r[user_idx, item_idx] = int(rating)
        test_mask_r[user_idx, item_idx] = 1

        user_test_set.add(user_idx)
        item_test_set.add(item_idx)

    return train_r, train_mask_r, test_r, test_mask_r, user_train_set, item_train_set, user_test_set, item_test_set

model 部分

import torch
import torch.nn as nn
import numpy as np
from torch.autograd import variable
from recommend.auto_rec.data import get_data
import math
import time
import argparse
import torch.utils.data as Data
import torch.optim as optim


class Autorec(nn.Module):
    def __init__(self, args, num_users, num_items):
        super(Autorec, self).__init__()

        self.args = args
        self.num_users = num_users
        self.num_items = num_items
        self.hidden_units = args.hidden_units
        self.lambda_value = args.lambda_value

        self.encoder = nn.Sequential(
            nn.Linear(self.num_items, self.hidden_units),
            nn.Sigmoid()
        )

        self.decoder = nn.Sequential(
            nn.Linear(self.hidden_units, self.num_items),
        )

    def forward(self, torch_input):

        encoder = self.encoder(torch_input)
        decoder = self.decoder(encoder)

        return decoder

    def loss(self, decoder, input, optimizer, mask_input):
        cost = 0
        temp2 = 0

        cost += ((decoder - input) * mask_input).pow(2).sum()
        rmse = cost

        for i in optimizer.param_groups:
            for j in i['params']:
                # print(type(j.data), j.shape,j.data.dim())
                if j.data.dim() == 2:
                    temp2 += torch.t(j.data).pow(2).sum()  # 正则化项

        cost += temp2 * self.lambda_value * 0.5
        return cost, rmse

    def train(self, epoch):
        RMSE = 0
        cost_all = 0
        for step, (batch_x, batch_mask_x, batch_y) in enumerate(loader):
            # batch_x = batch_x.type(torch.FloatTensor).cuda()
            # batch_mask_x = batch_mask_x.type(torch.FloatTensor).cuda()
            batch_x = batch_x.type(torch.FloatTensor)
            batch_mask_x = batch_mask_x.type(torch.FloatTensor)

            decoder = rec(batch_x)
            loss, rmse = rec.loss(decoder=decoder, input=batch_x, optimizer=optimer, mask_input=batch_mask_x)
            optimer.zero_grad()
            loss.backward()
            optimer.step()
            cost_all += loss
            RMSE += rmse

        RMSE = np.sqrt(RMSE.detach().cpu().numpy() / (train_mask_r == 1).sum())
        print('epoch ', epoch, ' train RMSE : ', RMSE)

    def test(self, epoch):
        # test_r_tensor = torch.from_numpy(test_r).type(torch.FloatTensor).cuda()
        # test_mask_r_tensor = torch.from_numpy(test_mask_r).type(torch.FloatTensor).cuda()
        test_r_tensor = torch.from_numpy(test_r).type(torch.FloatTensor)
        test_mask_r_tensor = torch.from_numpy(test_mask_r).type(torch.FloatTensor)

        decoder = rec(test_r_tensor)
        # decoder = torch.from_numpy(np.clip(decoder.detach().cpu().numpy(),a_min=1,a_max=5)).cuda()

        unseen_user_test_list = list(user_test_set - user_train_set)  # 得到未出现在训练集中的用户列表
        unseen_item_test_list = list(item_test_set - item_train_set)  # 得到未出现在训练集中的电影列表

        for user in unseen_user_test_list:
            for item in unseen_item_test_list:
                if test_mask_r[user, item] == 1:  # 如果在测试集中存在这条评分记录，则进行记录decoder[user,item]=3
                    decoder[user, item] = 3

        mse = ((decoder - test_r_tensor) * test_mask_r_tensor).pow(2).sum()
        RMSE = mse.detach().cpu().numpy() / (test_mask_r == 1).sum()
        RMSE = np.sqrt(RMSE)

        print('epoch ', epoch, ' test RMSE : ', RMSE)


if __name__ == '__main__':

    parser = argparse.ArgumentParser(description='I-AutoRec ')
    parser.add_argument('--hidden_units', type=int, default=500)  # 默认隐藏层单元数为500
    parser.add_argument('--lambda_value', type=float, default=1)

    parser.add_argument('--train_epoch', type=int, default=100)  # 训练次数默认为100次
    parser.add_argument('--batch_size', type=int, default=100)  # batch_size 默认为100

    parser.add_argument('--optimizer_method', choices=['Adam', 'RMSProp'], default='Adam')  # 默认使用Adam优化
    parser.add_argument('--grad_clip', type=bool, default=False)
    parser.add_argument('--base_lr', type=float, default=1e-3)  # 基础学习率设为1e-3
    parser.add_argument('--decay_epoch_step', type=int, default=50, help="decay the learning rate for each n epochs")

    parser.add_argument('--random_seed', type=int, default=1000)  # 随机数种子默认设为1000
    parser.add_argument('--display_step', type=int, default=1)

    args = parser.parse_args()

    np.random.seed(args.random_seed)

    data_name = 'ml-1m'
    num_users = 6040
    num_items = 3952
    num_total_ratings = 1000209
    train_ratio = 0.9  # 90%为训练集

    path = "../data/%s" % data_name + "/"

    train_r, train_mask_r, test_r, test_mask_r, user_train_set, item_train_set, user_test_set, \
    item_test_set = get_data(path, num_users, num_items, num_total_ratings, train_ratio)

    args.cuda = False  # 垃圾笔记本只能用cpu强行跑。。。

    rec = Autorec(args, num_users, num_items)
    # if args.cuda:
    # rec.cuda()

    optimer = optim.Adam(rec.parameters(), lr=args.base_lr, weight_decay=1e-4)

    num_batch = int(math.ceil(num_users / args.batch_size))

    torch_dataset = Data.TensorDataset(torch.from_numpy(train_r), torch.from_numpy(train_mask_r),
                                       torch.from_numpy(train_r))
    loader = Data.DataLoader(
        dataset=torch_dataset,
        batch_size=args.batch_size,
        shuffle=True
    )

    for epoch in range(args.train_epoch):
        rec.train(epoch=epoch)
        rec.test(epoch=epoch)

引用：

https://zhuanlan.zhihu.com/p/129891661

王喆老师的深度学习推荐系统

JohnBanana

关注

1
点赞
踩
8

收藏

觉得还不错? 一键收藏
1
评论
推荐系统-AutoRec 的推荐系统介绍与python实现

本文要介绍的模型是2015年由澳大利亚国立大学提出的AutoRec。它将自编码器（AutoEncoder）的思想和协同过滤结合，提出了一种但隐藏层的神经网络推荐model。因为简洁的网络结构和清晰易懂的模型原理，所以非常适合深度学习的推荐model 的入门模型来学习本文参考了王喆大佬的新书，《深度学习推荐系统》论文地址1.引言协同过滤模型的目的是利用用户对商品的偏好信息来提供个性化的推荐。AutoRec是一个新型的基于自动编码器的协同过滤模型。论文作者认为AutoRec与现有的将玻尔兹曼机
复制链接

扫一扫