基于baseline、svd和stochastic gradient descent的个性化推荐系统

最新推荐文章于 2022-07-20 11:05:32 发布
最新推荐文章于 2022-07-20 11:05:32 发布
阅读量2.1k 收藏 2
点赞数
分类专栏： ★推荐系统★

文章主要介绍的是koren 08年发的论文[1],  2.3部分内容（其余部分会陆续补充上来）。

koren论文中用到netflix 数据集， 过于大， 在普通的pc机上运行时间很长很长。考虑到写文章目地主要是已介绍总结方法为主，所以采用Movielens 数据集。

变量介绍


部分变量介绍可以参看《基于baseline和stochastic gradient descent的个性化推荐系统》


文章中，将介绍两种方法实现的简易个性化推荐系统，用RMSE评价标准，对比这两个方法的实验结果。

（1） svd + stochstic gradient descent 方法来实现系统。

（2） baseline + svd + stochastic gradient descent 方法来实现系统。

注：



方法1： svd + stochastic gradient descent

svd:  


cost  function:


梯度变化（利用stochastic gradient descent算法使上述的目标函数值，在设定的迭代次数内，降到最小）

''''' 
Created on Dec 13, 2012 
 
@Author: Dennis Wu 
@E-mail: hansel.zh@gmail.com 
@Homepage: http://blog.csdn.net/wuzh670 
 
Data set download from : http://www.grouplens.org/system/files/ml-100k.zip 
'''  
  
from operator import itemgetter, attrgetter  
from math import sqrt  
import random  
  
def load_data():  
      
    train = {}  
    test = {}  
    filename_train = 'data/ua.base'  
    filename_test = 'data/ua.test'  
      
    for line in open(filename_train):  
        (userId, itemId, rating, timestamp) = line.strip().split('\t')  
        train.setdefault(userId,{})  
        train[userId][itemId] = float(rating)  
    
    for line in open(filename_test):  
        (userId, itemId, rating, timestamp) = line.strip().split('\t')  
        test.setdefault(userId,{})  
        test[userId][itemId] = float(rating)  
          
    return train, test  
  
def calMean(train):  
    stat = 0  
    num = 0  
    for u in train.keys():  
        for i in train[u].keys():  
            stat += train[u][i]  
            num += 1  
    mean = stat*1.0/num  
    return mean  
  
def initialFeature(feature, userNum, movieNum):  
  
    random.seed(0)  
    user_feature = {}  
    item_feature = {}  
    i = 1  
    while i < (userNum+1):  
        si = str(i)  
        user_feature.setdefault(si,{})  
        j = 1  
        while j < (feature+1):  
            sj = str(j)  
            user_feature[si].setdefault(sj,random.uniform(0,1))  
            j += 1  
        i += 1  
      
    i = 1  
    while i < (movieNum+1):  
        si = str(i)  
        item_feature.setdefault(si,{})  
        j = 1  
        while j < (feature+1):  
            sj = str(j)  
            item_feature[si].setdefault(sj,random.uniform(0,1))  
            j += 1  
        i += 1  
    return user_feature, item_feature  
  
def svd(train, test, userNum, movieNum, feature, user_feature, item_feature):  
  
    gama = 0.02  
    lamda = 0.3  
    slowRate = 0.99  
    step = 0  
    preRmse = 1000000000.0  
    nowRmse = 0.0  
      
    while step < 100:  
        rmse = 0.0  
        n = 0  
        for u in train.keys():  
            for i in train[u].keys():  
                pui = 0  
                k = 1  
                while k < (feature+1):  
                    sk = str(k)  
                    pui += user_feature[u][sk] * item_feature[i][sk]  
                    k += 1  
                eui = train[u][i] - pui  
                rmse += pow(eui,2)  
                n += 1  
                k = 1  
                while k < (feature+1):  
                    sk = str(k)  
                    user_feature[u][sk] += gama*(eui*item_feature[i][sk] - lamda*user_feature[u][sk])  
                    item_feature[i][sk] += gama*(eui*user_feature[u][sk] - lamda**item_feature[i][sk])  
                    k += 1  
              
        nowRmse = sqrt(rmse*1.0/n)  
        print 'step: %d      Rmse: %s' % ((step+1), nowRmse)  
        if (nowRmse < preRmse):  
            preRmse = nowRmse  
              
        gama *= slowRate  
        step += 1  
          
    return user_feature, item_feature  
  
def calRmse(test, user_feature, item_feature, feature):  
      
    rmse = 0.0  
    n = 0  
    for u in test.keys():  
        for i in test[u].keys():  
            pui = 0  
            k = 1  
            while k < (feature+1):  
                sk = str(k)  
                pui += user_feature[u][sk] * item_feature[i][sk]  
                k += 1  
            eui = pui - test[u][i]  
            rmse += pow(eui,2)  
            n += 1  
    rmse = sqrt(rmse*1.0 / n)  
    return rmse;  
     
if __name__ == "__main__":  
  
    # load data  
    train, test = load_data()  
    print 'load data success'  
  
    # initial user and item feature, respectly  
    user_feature, item_feature = initialFeature(100, 943, 1682)  
    print 'initial user and item feature, respectly success'  
      
    # baseline + svd + stochastic gradient descent  
    user_feature, item_feature = svd(train, test, 943, 1682, 100, user_feature, item_feature)  
    print 'svd + stochastic gradient descent success'  
      
    # compute the rmse of test set  
    print 'the Rmse of test test is: %s' % calRmse(test, user_feature, item_feature, 100)

方法2：baseline + svd + stochastic gradient descent 

baseline + svd:


object function:


梯度变化（利用stochastic gradient descent算法使上述的目标函数值，在设定的迭代次数内，降到最小）


方法2： 具体代码实现

''''' 
Created on Dec 13, 2012 
 
@Author: Dennis Wu 
@E-mail: hansel.zh@gmail.com 
@Homepage: http://blog.csdn.net/wuzh670 
 
Data set download from : http://www.grouplens.org/system/files/ml-100k.zip 
'''  
  
from operator import itemgetter, attrgetter  
from math import sqrt  
import random  
  
def load_data():  
      
    train = {}  
    test = {}  
    filename_train = 'data/ua.base'  
    filename_test = 'data/ua.test'  
      
    for line in open(filename_train):  
        (userId, itemId, rating, timestamp) = line.strip().split('\t')  
        train.setdefault(userId,{})  
        train[userId][itemId] = float(rating)  
    
    for line in open(filename_test):  
        (userId, itemId, rating, timestamp) = line.strip().split('\t')  
        test.setdefault(userId,{})  
        test[userId][itemId] = float(rating)  
          
    return train, test  
  
def calMean(train):  
    stat = 0  
    num = 0  
    for u in train.keys():  
        for i in train[u].keys():  
            stat += train[u][i]  
            num += 1  
    mean = stat*1.0/num  
    return mean  
  
def initialBias(train, userNum, movieNum, mean):  
  
    bu = {}  
    bi = {}  
    biNum = {}  
    buNum = {}  
      
    u = 1  
    while u < (userNum+1):  
        su = str(u)  
        for i in train[su].keys():  
            bi.setdefault(i,0)  
            biNum.setdefault(i,0)  
            bi[i] += (train[su][i] - mean)  
            biNum[i] += 1  
        u += 1  
          
    i = 1  
    while i < (movieNum+1):  
        si = str(i)  
        biNum.setdefault(si,0)  
        if biNum[si] >= 1:  
            bi[si] = bi[si]*1.0/(biNum[si]+25)  
        else:  
            bi[si] = 0.0  
        i += 1  
  
    u = 1  
    while u < (userNum+1):  
        su = str(u)  
        for i in train[su].keys():  
            bu.setdefault(su,0)  
            buNum.setdefault(su,0)  
            bu[su] += (train[su][i] - mean - bi[i])  
            buNum[su] += 1  
        u += 1  
          
    u = 1  
    while u < (userNum+1):  
        su = str(u)  
        buNum.setdefault(su,0)  
        if buNum[su] >= 1:  
            bu[su] = bu[su]*1.0/(buNum[su]+10)  
        else:  
            bu[su] = 0.0  
        u += 1  
  
    return bu,bi  
  
def initialFeature(feature, userNum, movieNum):  
  
    random.seed(0)  
    user_feature = {}  
    item_feature = {}  
    i = 1  
    while i < (userNum+1):  
        si = str(i)  
        user_feature.setdefault(si,{})  
        j = 1  
        while j < (feature+1):  
            sj = str(j)  
            user_feature[si].setdefault(sj,random.uniform(0,1))  
            j += 1  
        i += 1  
      
    i = 1  
    while i < (movieNum+1):  
        si = str(i)  
        item_feature.setdefault(si,{})  
        j = 1  
        while j < (feature+1):  
            sj = str(j)  
            item_feature[si].setdefault(sj,random.uniform(0,1))  
            j += 1  
        i += 1  
    return user_feature, item_feature  
  
def svd(train, test, mean, userNum, movieNum, feature, user_feature, item_feature, bu, bi):  
  
    gama = 0.02  
    lamda = 0.3  
    slowRate = 0.99  
    step = 0  
    preRmse = 1000000000.0  
    nowRmse = 0.0  
      
    while step < 100:  
        rmse = 0.0  
        n = 0  
        for u in train.keys():  
            for i in train[u].keys():  
                pui = 1.0 * (mean + bu[u] + bi[i])  
                k = 1  
                while k < (feature+1):  
                    sk = str(k)  
                    pui += user_feature[u][sk] * item_feature[i][sk]  
                    k += 1  
                eui = train[u][i] - pui  
                rmse += pow(eui,2)  
                n += 1  
                bu[u] += gama * (eui - lamda * bu[u])  
                bi[i] += gama * (eui - lamda * bi[i])  
                k = 1  
                while k < (feature+1):  
                    sk = str(k)  
                    user_feature[u][sk] += gama*(eui*item_feature[i][sk] - lamda*user_feature[u][sk])  
                    item_feature[i][sk] += gama*(eui*user_feature[u][sk] - lamda*item_feature[i][sk])  
                    k += 1  
              
        nowRmse = sqrt(rmse*1.0/n)  
        print 'step: %d      Rmse: %s' % ((step+1), nowRmse)  
        if (nowRmse < preRmse):  
            preRmse = nowRmse  
              
        gama *= slowRate  
        step += 1  
    return user_feature, item_feature, bu, bi  
  
def calRmse(test, bu, bi, user_feature, item_feature, mean, feature):  
      
    rmse = 0.0  
    n = 0  
    for u in test.keys():  
        for i in test[u].keys():  
            pui = 1.0 * (mean + bu[u] + bi[i])  
            k = 1  
            while k < (feature+1):  
                sk = str(k)  
                pui += user_feature[u][sk] * item_feature[i][sk]  
                k += 1  
            eui = pui - test[u][i]  
            rmse += pow(eui,2)  
            n += 1  
    rmse = sqrt(rmse*1.0 / n)  
    return rmse;  
     
if __name__ == "__main__":  
  
    # load data  
    train, test = load_data()  
    print 'load data success'  
      
    # Calculate overall mean rating  
    mean = calMean(train)  
    print 'Calculate overall mean rating success'  
  
    # initial user and item Bias, respectly  
    bu, bi = initialBias(train, 943, 1682, mean)  
    print 'initial user and item Bias, respectly success'  
  
    # initial user and item feature, respectly  
    user_feature, item_feature = initialFeature(100, 943, 1682)  
    print 'initial user and item feature, respectly success'  
      
    # baseline + svd + stochastic gradient descent  
    user_feature, item_feature, bu, bi = svd(train, test, mean, 943, 1682, 100, user_feature, item_feature, bu, bi)  
    print 'baseline + svd + stochastic gradient descent success'  
      
    # compute the rmse of test set  
    print 'the Rmse of test test is: %s' % calRmse(test, bu, bi, user_feature, item_feature, mean, 100)

实验参数设置：

   

(gama = 0.02  lamda =0.3)

   feature = 100 maxstep = 100 slowRate = 0.99(随着迭代次数增加，梯度下降幅度越来越小) 


方法1结果：Rmse of test set : 1.00422938926

方法2结果：Rmse of test set : 0.963661477881

REFERENCES

1.Y. Koren. Factorization Meets the Neighborhood: a Multifaceted Collaborative Filtering Model. Proc. 14th ACM SIGKDD Int. Conf. On Knowledge Discovery and Data Mining  (KDD’08), pp. 426–434, 2008.

2. Y.Koren.  The BellKor Solution to the Netflix Grand Prize  2009



longgongshiye
关注
专栏目录
推荐系统整理（一）Baseline
VotaverUno的博客
05-03 841
序 其实我发现我很多内容都是只有（一） 因为很多东西学了又懒得再发出来了，所以都只剩个开头。往往都觉得，开头必须开个好头，到了后面学了又什么也不想写了。但，总而言之，重要的东西还是记一记。自用自用。 这里是实验室朋友邀请去推荐系统比赛，我最近都在搞信号，好久没有做大数据了，得重新看起。首先，对推荐系统常用模型做一个整理吧。（协同那些我就略去了） Baseline 我认为这就是一个均值波动（我自己乱创的词）。 一般来说，大数据量的所有人的评分平均，就是一个比较合理的结果。 由于个人原因，每个人对每一个物品的评
KDD推荐系统baseline运行
Major_S的博客
05-13 762
待留
基于内容推荐的个性化新闻阅读实现（二）：基于SVD的推荐算法
张伟的专栏
06-24 4439
基于内容推荐的个性化新闻阅读实现（二）：基于SVD的推荐算法 时间 2016-06-24 12:23:02  Nicol的博客铭 原文  https://taozj.org/2016/06/基于内容推荐的个性化新闻阅读实现（二）：基于SVD的推荐算法/ 主题 奇异值分解 推荐系统 一、前言 SVD前面已经说了好多次了，先不论其信息检索被宣称的各种长处如何如何，在此
零基础入门推荐系统：Task01 Baseline
不忘初心，方得始终
11-25 389
此为DataWhale与天池联合举办的新人赛——新闻推荐，第一个小任务：实现一个Baseline
推荐系统总结：重现推荐系统若干算法
志向和热爱是伟大行为的双翼
07-29 2808
非个性化模型(Non-personalized models)：Movie Average（MovieAvg）和Top Popular(TopPop)； 邻域模型(Neighborhood models)：Correlation Neighborhood models(CorNgbr)和Non-normalized Cosine Neighborhood(NNCosNgbr)； 隐语义模型（Latent Factor Model）：Asymmetric-SVD(AsySVD)、SVD++和PureSVD
“泰迪杯” 挑战赛 - 利用协同过滤与卷积神经网络为电视产品制订智能化营销推荐
weixin_47922824的博客
04-14 2476
目录 问题重述 模型假设 数据预处理 3.1 数据清洗 3.1.1 数据缺失的分析和处理 3.1.2 数据异常的分析和处理 3.2 数据规约 数据分析 4.1 电视产品体系图 4.2 收视用户体系图 4.3 用户收视信息分析 4.3.1 用户收视信息 4.3.2 用户回看信息 4.3.3 用户点播信息 4.3.4 用户单片点播信息 4.4 电视产品信息数据分析 4.5 用户基本信息分析 4.6 产品与用户画像 4.7 评分体系 推荐系统算法设计 5.1 协同过滤算法 5.1.1 基于用户的协同过滤算法 5
对MovieLens 数据集进行评分预测-ALS 与 Surprise 工具的使用-详细解释
Chowzheng的博客
06-25 1941
对MovieLens 数据集进行评分预测-ALS 与 Surprise 工具的使用-详细解释理论基础surprise 中的常用算法surprise 推荐系统工具算法描述model_selection 包项目解析BaslineOnly算法理论部分代码讲解knn.KNNbasic理论解析代码讲解 理论基础 surprise 中的常用算法 Baseline 算法 基于邻域的协同过滤 矩阵分解：SVD, SVD++,PMF,NMF slopeOne 协同过滤算法 关于surprise 使用方法的说明 surpr
SVRG&Lissa&NewSamp实现
xfzero的博客
07-07 2427
SVRG, NewSamp &amp;amp;amp;amp; Lissa 实现 具体实现参见Github,算法分析可以参我的一篇二阶算法博客 SVRG, NewSamp &amp;amp;amp;amp; Lissa 这是基于python实现的SVRG, NewSamp, Lissa的baseline 数据集采用的是Mnist49(手写数据集中的4和9) SVRG 算法分析 SVRG（Stochastic Varia...
【2011-2016】 NIPS汇总 - Advances in Neural Information Processing Systems
Testing的博客
10-02 1万+
Advances in Neural Information Processing Systems 24 (NIPS 2011) The papers below appear in Advances in Neural Information Processing Systems 24 edited by J. Shawe-Taylor and R.S. Zemel and P.L.
Recommender-Baseline-Model:常用的推荐基准模型，包括传统的统计模型和神经网络模型。 专注于SRS（顺序推荐系统）
03-28
推荐人基线模型 常用的推荐系统基准模型，包括传统的统计模型和神经网络模型。 专注于SRS（顺序推荐系统）。 信息 神经网络 统计模型
入门推荐系统必读的10篇baseline paper
Kaiyuan_sjtu的博客
07-20 381
经常有粉丝留言问我：推荐系统应该怎么入门？我建议想入门推荐系统的同学，从rank任务学起，优先去读以下10篇推荐系统的baseline 论文。01推荐系统10篇baseline论文1、Wide & Deep Learning for Recommender Systems2、DeepFM: A Factorization-Machine based Neural ...
推荐系统赛题理解
Arya的博客，专注后端领域
11-25 216
根据赛题简介，我们首先要明确我们此次比赛的目标： 根据用户历史浏览点击新闻的数据信息预测用户最后一次点击的新闻文章。从这个目标上看， 会发现此次比赛和我们之前遇到的普通的结构化比赛不太一样， 主要有两点： 首先是目标上， 要预测最后一次点击的新闻文章，也就是我们给用户推荐的是新闻文章， 并不是像之前那种预测一个数或者预测数据哪一类那样的问题 数据上， 通过给出的数据我们会发现， 这种数据也不是我们之前遇到的那种特征+标签的数据，而是基于了真实的业务场景， 拿到的用户的点击日志 所以拿到这个题目，我们的思考方
基于baseline和stochastic gradient descent的个性化推荐系统
做个假设——坚持两年，我会怎么样
11-10 1934
文章主要介绍的是koren 08年发的论文[1],  2.1 部分内容（其余部分会陆续补充上来）。  koren论文中用到netflix 数据集， 过于大， 在普通的pc机上运行时间很长很长。考虑到写文章目地主要是已介绍总结方法为主，所以采用Movielens 数据集。 要用到的变量介绍： Baseline estimates       object f
【Applied Algebra】求解布尔方程(Boolean Equations)的4个高效baseline算法
MinCong Luo的博客
05-25 2775
求解布尔方程(Boolean Equations)的4个高效baseline算法 求解布尔方程(Boolean Equations)是理论计算机中的基本问题之一;事实上,求解Fq\mathbb{F}_qFq​上nnn个变量的mmm个非线性多项式方程组是一个基础的数学问题,受到了包括密码学界在内的各个理论计算机研究方向的广泛关注;众所周知,AI领域的计算机视觉和自然语言处理就有许多具体任务(比如人脸识别,语义分割)的baselines(也就是提供参考对比的基线模型/算法),那么自然研究求解布尔方程也有对应
NLP中文预训练模型泛化能力挑战赛-Baseline算法实现
徐先森的博客
12-30 716
NLP中文预训练模型泛化能力挑战赛，使用tensorflow1.x版本实现Baseline算法，第一阶段分数0.6236
第07课：RNN 在序列问题中的应用——文本分类
万宫玺的专栏
09-22 577
本节课我们介绍另一种常用的神经网络结果——循环神经网络（Recurrent Neural Network，RNN）。需要注意的是，RNN 可以是两种神经网络的缩写，一种是本次课程讨论的 Recurrrent Neural Network，另一种则是 Recursive Neural Network，也称递归神经网络。前者是时间递归的神经网络，而后者是结构递归。在下文中，如果不特别说明，RNN 都代...
推荐算法之BaselineOnly算法（Python实现）
给我一点温度
07-29 1859
要评估一个策略的好坏，就需要建立一个对比基线，以便后续观察算法效果的提升。 而Baseline算法的思想就是设立基线，并引入用户的偏差以及电影的偏差。 在上式中，等式中的是待求的基线模型中用户u给物品i打分的预估值； 等式右边的μ为所有用户对电影评分的均值；bu为user偏差（如果某用户比较苛刻，打分都相对偏低， 则bu会为负值；相反，如果某用户经常对很多片都打正分， 则bu为正值）；...
【简单易懂】Benchmark和baseline的区别！
热门推荐
qq_37791134的博客
12-11 4万+
作者：Anonymous 链接：https://www.zhihu.com/question/28823373/answer/101504099 来源：知乎 著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。 Benchmark和baseline都有性能比较的意思。 先看看字典定义。 benchmark：N-COUNT A benchmark is something whos...
知识图谱推荐系统baseline代码
最新发布
08-31
知识图谱推荐系统的baseline代码是指在搭建推荐系统时的初始代码框架。该框架用于构建基础的推荐模型，包括数据预处理、特征工程、模型训练和推荐结果生成等步骤。 在数据预处理阶段，可以使用代码将原始数据清洗、...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值