精华内容
下载资源
问答
  • 协同过滤算法

    2019-04-30 21:23:44
    自己总结的协同过滤算法的流程图,希望能被大家参考!!!
  • Spark 基于用户的协同过滤算法 1 一 基于用户协同过滤简介 基于用户的协同过滤算法 (user-based collaboratIve filtering) 基于用户的协同过滤算法是通过用户的历史行为数据发现用户对商品或内容的喜欢 (如商品购买...
  • 基于用户协同过滤算法系统介绍.ppt
  • 推荐系统-经典协同过滤理论...UserCF用户协同过滤算法 ItemCF物品的协同过滤推荐算法 基于模型的协同过滤 ---- 隐因子 LFM(latent fator machine)隐藏因子的分解模型-----矩阵分解(将一个矩阵分解成连个矩阵的乘...

    推荐系统-经典协同过滤理论基础实践

    1.协同过滤推荐方法CF简介

    • 协同过滤CF
      • 基于记忆的协同过滤 ---- 用户和物品的相似度矩阵
        • 用户相似度的推荐
        • 物品相似度推荐
        • UserCF用户协同过滤算法
        • ItemCF物品的协同过滤推荐算法
      • 基于模型的协同过滤 ---- 隐因子
        • LFM(latent fator machine)隐藏因子的分解模型-----矩阵分解(将一个矩阵分解成连个矩阵的乘积)----Y=A*B
        • ALS(Alternative least square) 交替最小二乘法
        • SVD分解—奇异值分解(无因变量)
        • SVD++(SVDPP)----加入因变量

    2.U-U矩阵相似度推荐-Pearson

    在这里插入图片描述

    • pearson相关系数=====公式:协方差/标准差
    • 算法原理 ----Pearson相关系数
      在这里插入图片描述
    • Pearson系数存在的问题
      • 不能应对不同用户可能对某一件广受欢迎的项目都给予高评分的情况
      • 在遇到用户只对非常少的共同项目评分时出现预测不准的情况
    • 解决方案 : 提高了对有争议的共同评价的相对重要性,降低了广受欢迎项目有共同评价的相对重要性
    • 算法部分:
      • 算法思想:通过Pearson相似度度量公式计算用户之间的相似度,构建相似度矩阵,实现简单的用户的推荐
      • 算法流程

    在这里插入图片描述

    • 算法步骤:

      • 输入:用户行为数据—userid-itemid-rating
      • 输出:用户相似度矩阵
      • 步骤
        • 1.计算各个用户之间同时购买商品的相似度
        • 2.当前用户和其他用户分别计算相似度,构建相似度矩阵
    • 算法优化

      • 需要考虑打分分值
      • 提出UserCF-基于用户的协同过滤算法

    在这里插入图片描述

    3.V-V矩阵相似度推荐-cos

    • pearson相关系数=====公式:协方差/标准差
    • 算法原理

    在这里插入图片描述

    在这里插入图片描述

    • 算法流程

    在这里插入图片描述

    • 算法部分:

      • 算法思想:通过修正后的余弦公式相似度度量公式计算用户之间的相似度,构建物品相似度矩阵,实现简单的用户的推荐
      • 算法步骤:
        • 输入:用户行为数据—userid-itemid-rating
        • 输出:物品相似矩阵
        • 步骤
          • 1.计算各个物品之间同时购买商品的相似度
          • 2.当前用户购买的物品和其他用户同时购买的商品计算相似度,构建相似度矩阵
      • 算法优化
        • 需要考虑打分分值
        • 提出-ItemCF-基于物品的协同过滤算法

    在这里插入图片描述

    4.U-V矩阵的相似度推荐

    • 通过对用户和物品的隐式或显式打分数据通过UV矩阵形成,进入用于UserCF和ItemCF

    5.基于用户的CF详解

    • 算法思想:将UU矩阵得到的相似度矩阵作为输入,结合用户行为数据,构建用户对未知商品的打分,进行去重过滤排序得到最后的推荐结果
    • 算法流程

    在这里插入图片描述

    • 算法步骤:
      • 获取UU矩阵用户和用户之间的相似度
      • 将用户的其他用户之间的相似度与用户对商品的打分相乘得到用户对商品的综合评价得分
      • 对评价得分按照从大到小的顺序进行抽取TopN
      • 获得初始推荐结果
    • 算法特点:
      • 在用户数量急剧增加的情况下,需要对比多个用户之间的相似度,算法性能会出现瓶颈
    • 算法使用场景:
      • 物品数量较多的时候,可优先选择用户CF—UserCF
    • 基于用户的CF图解1

    在这里插入图片描述

    • 基于用户的CF图解2

    在这里插入图片描述

    6.基于物品的CF详解

    • 算法思想:将VV矩阵得到的相似度矩阵作为输入,结合用户行为数据,构建用户对未知商品的打分,进行去重过滤排序得到最后的推荐结果
    • 算法流程

    在这里插入图片描述

    • 算法步骤:
      • 获取VV矩阵物品和物品之间的相似度
      • 将用户购买的物品和其他物品之间的相似度与用户对商品的打分相乘得到用户对商品的综合评价得分
      • 对评价得分按照从大到小的顺序进行抽取TopN
      • 获得初始推荐结果
    • 算法特点:
      • 在物品数量急剧增加的情况下,需要对比多个物品之间的相似度,算法性能出现瓶颈
    • 算法使用场景:
      • 当用户数量较多的时候,可优先选择ItemCF
    • 基于物品的CF图解1

    在这里插入图片描述

    • 基于物品的CF图解2

    在这里插入图片描述

    7.UserCF和ItemCF区别和联系

    • UserCF基于用户的相似度推荐
      • 应用场景:用户数据量较少的或物品数据量较多的时候
      • 冷启动:新用户冷启动无法实时更新,物品的冷启动是需要在用户产生行为的情况下可以推荐新物品
      • 推荐理由:相似的用户也购买、浏览什么商品
    • ItemCF基于物品的相似度推荐
      • 应用场景:物品的数据较少或用户数量较多的时候
      • 冷启动:物品冷启动,只有等物品相似度矩阵更新之后基于用户行为进行新物品推荐
      • 推荐理由:您购买的物品的相似物品
    • 协同过滤优点:实现快、对商品和物品没有要求、效果有保障
    • 协同过滤缺点:冷启动、马太效应 (热门商品问题)、推荐解析模糊
    • 长尾分布 : 正态分布的阈值的两侧的部分 ----最好采用ItemCF
    • 哈利波特问题

    在这里插入图片描述

    • 区别与联系表

    在这里插入图片描述

    8.推荐算法实战协同过滤源码之UserCF分析

    Jaccard公式和余弦公式回顾

    在这里插入图片描述

    扩展距离度量公式

    在这里插入图片描述

    • UV矩阵-----VU矩阵(倒排)-------UU矩阵(相似度)

    在这里插入图片描述

    • 进行相似度计算

    在这里插入图片描述

    • P(u,i)=sum(sim(u,i)*Rate)
    • UserCF协同过滤计算过程

    在这里插入图片描述

    • 源码实战:
      • 数据集导入,切分数据集形成训练集和测试集
      • 定义UserBasedCF类,读入数据,整个逻辑处理
      • 定义用户相似度计算—定义倒排表—计算相似度权值
      • P=score*sim
      • 推荐:首先拿到K个用户,拿相似的K个用户的N个商品

    9.推荐算法实战协同过滤源码之ItemCF分析

    • UV矩阵—无需进行倒排表-----统计VV矩阵(物品和物品的相似度)
    • 进行物品和物品的相似度计算—Jacard距离
    • P(u,i)=sum(i,j)*R(U,j)

    在这里插入图片描述

    • 源码实战:
      • 数据集导入,切分数据形成训练集和测试集
      • 定义ItemBaseCF类,读入数据,整个逻辑
      • 定义VV矩阵(无需倒排表即可完成VV矩阵统计)
      • P=score*sim
      • 拿到用户浏览商品的近K个最接近商品,从中选择M个偏好值较高的商品

    结论:根据UserCF和ItemCF得到的结果相似,这里的度量的方式不同,rank排名是不同的,这点需要注意

    扩展 : 收集用户偏好的方法

    用户行为类型特征作用
    评分显式整数量化的偏好,可能的取值是n;n一般取值为5或者是10通过用户对物品的评分,可以精确的得到用户的偏好
    投票显式布尔量化的偏好,取值是0或1通过用户对物品的投票,可以较精确的得到用户的偏好
    转发显式布尔量化的偏好,取值是0或1通过用户对物品的投票,可以精确的得到用户的偏好。
    如果是站内,同时可以推理得到被转发人的偏好(不精确)
    保存书签显示布尔量化的偏好,取值是0或1通过用户对物品的投票,可以精确的得到用户的偏好。
    标记标签显示一些单词,需要对单词进行分析,得到偏好通过分析用户的标签,可以得到用户对项目的理解,同时可以分析出用户的情感:喜欢还是讨厌
    (Tag)
    评论显示一段文字,需要进行文本分析,得到偏好通过分析用户的评论,可以得到用户的情感:喜欢还是讨厌
    点击流隐式一组用户的点击,用户对物品感兴趣,需要进行分析,得到偏好用户的点击一定程度上反映了用户的注意力,所以它也可以从一定程度上反映用户的喜好。
    ( 查看)
    页面停留时间隐式一组时间信息,噪音大,需要进行去噪,分析,得到偏好用户的页面停留时间一定程度上反映了用户的注意力和喜好,但噪音偏大,不好利用。
    购买隐式布尔量化的偏好,取值是0或1用户的购买是很明确的说明这个项目它感兴趣。

    10.基于相似度推荐源码实战

    • 通过cos计算余弦相似度
    • 导入用户和商品的数据,首先通过制表符进行分割,userid、itemid、rating
    • 构建倒排表:构建UU矩阵—用cos相似度计算—将结果返回
    • 计算推荐列表:通过用户的协同过滤算法得到每个商品的得分,给到最终推荐列表。

    11.Mahout是什么

    • Mahout是机器学习库,集成了大部分机器学习算法,利用算法结合数据建立模型,Mahout是基于MR的机器学习框架,现在Mahout已经废弃了MR作为底层执行引擎,改为了Spark作为底层引擎,支持Scala语言。

    12.Mahout能做什么

    • Mahout可以做推荐引擎
    • Mahout可以实现分类
    • Mahout可以实现聚类等场景

    13.Mahout协同过滤算法

    • DataModel
      • 本地文件、JDBC\Mysql等介质中获取数据
    • 相似度度量方法
      • SimlarityUser、SimlarityItem
    • 最近邻
      • 最近的K个邻居
      • UserNeighborhood
    • 推荐引擎Recommender
      • UserBaseRecomender
      • ItemBaseRecommender
    • 推荐结果评价
      • rmse–根均方误差
      • 召回率、分类准确率等

    14.Mahout协同过滤算法编程

    • 大致流程:
      • 加载数据
      • 实现基于用户或基于物品的相似度计算
      • 实现用户的最近的K个邻居的查找
      • 通过UserCF和ItemCF类进行协同过滤推荐
      • 通过RMSE验证效果、使用prescition和recall共同查看性能
    • Mahout提供了GenericItemBasedRecommender、GenericUserBasedRecommender
    • 通过两个推荐方法可以将用户的协同过滤和物品的协同过滤通过推荐器进行加载推荐

    15.基于Mahout混合推荐业务需求分析和数据准备

    • 业务需求:
      • 24个推荐位
        • 1个硬广
        • 6个推荐位*4次=24个推荐位通过不同的模型进行推荐
    • 数据:
      • 通过网络爬虫方式
      • 商品id、商品name、商品url、商品价格、商品图片
      • 假设有一个guyong用户在对应的121推荐位推荐商品

    16.基于Mahout混合推荐业务功能实现分析和产品原型设计

    • 功能实现
      • 数据来源:用户的cookies数据、点击流埋点日志中获取
      • 离线推荐:基于历史数据的协同过滤推荐、用户上一次浏览的记录基于物品的协同过滤、用户上一次浏览记录的基于内容的推荐
      • 实时推荐:基于物品和基于内容推荐24个商品
      • 对离线和实时的推荐商品需要进行排序、过滤、去重

    17.基于Mahout混合推荐项目开发及补充

    • 项目架构:
      • 数据平台:提供三种推荐引擎-基于用户CF、基于物品的CF、基于内容的推荐、用户画像
      • 结果和相似物品和相似用户存储:存储在Redis中,如存储和id=100相似的400个用户
      • 实时推荐:获取正在浏览商品的信息或用户信息,和已经存放在redis中的相似用户或相似商品的内容进行比对,得到实时推荐结果
      • 在得到初始的召回结果之后通过排序和过滤、补足等功能完成最终初始推荐结果
      • 存放在Redis中供前端去调用
    • 代码:
      • 获取产品信息(通过网络爬虫)
      • 猜你喜欢推荐接口----实现接口
      • 猜你喜欢的主要流程—广告位和用户涉及
      • 通过固定的广告位进行推荐,绑定用户进行推荐
      • 根据业务规则或后台进行重复商品数据的去重
      • 初始数据进行商品推荐

    18.基于模型的CF理解

    • 基于模型的CF是为了解决基于记忆的CF需要大量使用内存进行相似度的计算,只需要借助于模型就可以直接将数据通过模型得到预测值,而不需要全部将数据放入内存进行计算,避免了因为内存不足或计算复杂度太高带来的影响。
    • Y=A(m*n)*B(n*K)
    • 简单理解:用户对电影的评分==用户对电影本身评分*电影本身具备特性评分
    • LFM简称是:Latent Factor Machine 隐藏因子分析
      • 理解:通过上面的理解,将一个矩阵分解为两个具有具体业务场景的矩阵,但是在实际使用LFM模型中实际上矩阵的分解是不清楚具体的物理含义,因此,叫做隐藏因子。具体来讲上述的两个A矩阵和B矩阵可以使用随机数进行初始化,通过机器学习算法进一步学习得到最终评分。

    在这里插入图片描述

    19.基于LFM推荐算法

    • 基于隐因子模型分解的方法
    • 初始化分解后的矩阵A和B
    • 构建损失函数sum(r(ij)-P*Q.T)
    • 求解损失函数最优解—关于P矩阵求解导数,关于Q矩阵求解导数
    • 利用梯度下降法求解P和Q矩阵的最优解
    • 得到最佳的P和Q导数的最优解,估计其他未知位置的数据,进行推荐
    • LFM推荐可解析性很弱

    20.补充知识点:梯度下降法

    • 基于有一个损失函数(目标函数、误差函数)
    • 求解函数最优解
      • 解析解
      • 最优解-----梯度下降法
    • 梯度下降法====
      • 什么是梯度===
        • 梯度是方向导数最大值的方向,梯度的值是方向导数最大值的值
        • 源自于方向导数==
          • 源自于偏导数==
            • 源自于导数====
              • 源自于切线斜率====
      • 用于最优解求解
        • X(k+1)=X(K)-alpha* df(梯度算子)
        • df就是求解的位置参数的导数

    在这里插入图片描述

    21.LFM总结

    • Latent Factor Machine-隐因子模型
    • Y=A*B其中A和B是分解后的含有隐因子的矩阵
    • 利用机器学习算法通过构建损失函数,结合梯度下降法达到求解A矩阵和B矩阵的最优解
    • 通过A和B的最优解求解得到Y的预测值,根据预测值的大小进行排序,拿到TopN个商品进行相关联推荐

    22.总结

    在这里插入图片描述

    展开全文
  • 硕士论文,Netflix数据集上的协同过滤算法 硕士论文,Netflix数据集上的协同过滤算法 硕士论文,Netflix数据集上的协同过滤算法 硕士论文,Netflix数据集上的协同过滤算法
  • 用户协同过滤算法

    2018-11-13 20:23:38
    基于用户的协同过滤算法(user-based collaboratIve filtering)
  • 为了解决传统协同过滤算法的冷启动问题,提高算法的推荐质量,本文针对协同过滤算法中的冷启动问题进行研究,提出了两种改进的算法.新用户冷启动:融合用户信息模型的基于用户的协同过滤算法;新项目冷启动:采用...
  • Python分析和实现基于用户和Item的协同过滤算法

    万次阅读 多人点赞 2016-05-30 12:08:02
    打开微信扫一扫,关注...1:协同过滤算法简介 2:协同过滤算法的核心 3:协同过滤算法的应用方式 4:基于用户的协同过滤算法实现 5:基于物品的协同过滤算法实现 一:协同过滤算法简介 关于协同过滤的...

                                                                            打开微信扫一扫,关注《搜索与推荐Wiki》

     

    1:协同过滤算法简介

    2:协同过滤算法的核心

    3:协同过滤算法的应用方式

    4:基于用户的协同过滤算法实现

    5:基于物品的协同过滤算法实现

     

    一:协同过滤算法简介

        关于协同过滤的一个最经典的例子就是看电影,有时候不知道哪一部电影是我们喜欢的或者评分比较高的,那么通常的做法就是问问周围的朋友,看看最近有什么好的电影推荐。在问的时候,都习惯于问跟自己口味差不 多的朋友,这就是协同过滤的核心思想。

       协同过滤是在海量数据中挖掘出小部分与你品味类似的用户,在协同过滤中,这些用户成为邻居,然后根据他们喜欢的东西组织成一个排序的目录推荐给你。所以就有如下两个核心问题

       (1)如何确定一个用户是否与你有相似的品味?

       (2)如何将邻居们的喜好组织成一个排序目录?

       协同过滤算法的出现标志着推荐系统的产生,协同过滤算法包括基于用户和基于物品的协同过滤算法。

     

    二:协同过滤算法的核心

          要实现协同过滤,需要进行如下几个步骤 

          1)收集用户偏好

          2)找到相似的用户或者物品

          3)计算并推荐

     

    三:协同过滤算法的应用方式

    1:基于用户的协同过滤算法   

    基于用户的协同过滤通过不同用户对物品的评分来评测用户之间的相似性,基于用户的相似性做推荐,简单的讲:给用户推荐和他兴趣相投的其他用户喜欢的物品

    算法实现流程分析:

    (1):计算用户的相似度

    计算用户相似度的方法请参考这篇博客:点击阅读  这里我采用的是余弦相似度

    下面我拿这个图举例

        

    计算用户的相似度,例如A,B为

    同理

             但是这样计算的效率是低的,因为我们需要计算每一对用户之间的相似度,事实上,很多用户相互之间并没有对同样的物品产生过行为,所以很多时候当分子为0的时候没有必要再去计算分母,所以这里可以优化:即首先计算出|N(u) 并 N(v)| != 0 的用户对(u,v),然后对这种情况计算分母以得到两个用户的相似度。

     

    针对此优化,需要2步:

         (1)建立物品到用户的倒查表T,表示该物品被哪些用户产生过行为;

         (2)根据倒查表T,建立用户相似度矩阵W:在T中,对于每一个物品i,设其对应的用户为j,k,在W中,更新相应的元素值,w[j][k]=w[j][k]+1,w[k][j]=w[k][j]+1,以此类推,扫描完倒查表T中的所有物品后,就可以得到最终的用户相似度矩阵W,这里的W是余弦相似度中的分子部分,然后将W除以分母可以得到最终的用户兴趣相似度。

    得到用户的相似度后,便可以进行下一步了

     

    (2):给用户推荐兴趣最相近的k个用户所喜欢的物品

    公式如下:

    其中,p(u,i)表示用户u对物品i的感兴趣程度,S(u,k)表示和用户u兴趣最接近的K个用户,N(i)表示对物品i有过行为的用户集合,Wuv表示用户u和用户v的兴趣相似度,Rvi表示用户v对物品i的兴趣(这里简化,所有的Rvi都等于1)。

    根据UserCF算法,可以算出,用户A对物品c、e的兴趣是:

    2:基于物品的协同过滤算法

    基于item的协同过滤通过不同用户对不同item的评分来评测item之间的相似性,基于item的相似性做推荐,简单的讲:给用户推荐和他之前喜欢物品相似的物品

    算法流程分析:

    同样拿上边的图举例,在这里默认用户对物品的打分均为1

    (1):构建物品的同现矩阵

    在这里对矩阵做归一化处理就可以得到物品之间的余弦相似度矩阵了其中归一化处理

    按照标准定义

    这里,分母|N(i)|是喜欢物品i的用户数,而分子 N(i) N( j) 是同时喜欢物品i和物品j的用户数。因此,上述公式可以理解为喜欢物品i的用户中有多少比例的用户也喜欢物品j。

     

    进行处理后的结果为:

    当然为了出现推荐热门的商品,对上述公式的优化为:

    这个公式惩罚了物品j的权重,因此减轻了热门物品会和很多物品相似的可能性(此种情况下感兴趣的自己推导)。

     

    (2):建立用户对物品的评分矩阵(以A举例,没有评分的物品为0)

     

    (3):矩阵计算推荐结果

    这里N(u)是用户喜欢的物品的集合,S(j,K)是和物品j最相似的K个物品的集合,wji是物品j和i的相似度,rui是用户u对物品i的兴趣。(对于隐反馈数据集,如果用户u对物品i有过行为,即可令rui=1。)该公式的含义是,和用户历史上感兴趣的物品越相似的物品,越有可能在用户的推荐列表中获得比较高的排名。

    推荐结果=同现矩阵 * 评分矩阵

    从中去掉A已经打过分的物品,a,b,d,则可以看出,A对e的喜欢程度和c一样,和上边计算结果一致,所以就会将两者推荐给A

    3:混合推荐

     

    所谓的混合算法,主体思路还是基于用户的协同过滤,只是在计算两个用户的相似度时又嵌套了item-based CF思想。

    度量用户i和用户j相似度更好的方法是:

    1.用户i参与评分的项目集合为IiIi,用户j参与评分的项目集合为IjIj,找到它们的并集Uij=Ii∪IjUij=Ii∪Ij

    2.在集合UijUij中用户i未评分的项目是Ni=Uij−IiNi=Uij−Ii,采用item-based CF方法重新估计用户i对NiNi中每个项目的评分。

    3.这样用户i和j对UijUij的评分就都是非0值了,在此情况下计算他们的相似度。

    四:基于用户的协同过滤算法实现

     

    #-*-coding:utf-8-*-
    '''
    Created on 2016年5月2日
    
    @author: Gamer Think
    '''
    from math import sqrt
    
    fp = open("uid_score_bid","r")
    
    users = {}
    
    for line in open("uid_score_bid"):
        lines = line.strip().split(",")
        if lines[0] not in users:
            users[lines[0]] = {}
        users[lines[0]][lines[2]]=float(lines[1])
    
    
    #----------------新增代码段END----------------------
    
    
    
    class recommender:
        #data:数据集,这里指users
        #k:表示得出最相近的k的近邻
        #metric:表示使用计算相似度的方法
        #n:表示推荐book的个数
        def __init__(self, data, k=3, metric='pearson', n=12):
    
            self.k = k
            self.n = n
            self.username2id = {}
            self.userid2name = {}
            self.productid2name = {}
    
            self.metric = metric
            if self.metric == 'pearson':
                self.fn = self.pearson
            if type(data).__name__ == 'dict':
                self.data = data
          
        def convertProductID2name(self, id):
    
            if id in self.productid2name:
                return self.productid2name[id]
            else:
                return id
    
        #定义的计算相似度的公式,用的是皮尔逊相关系数计算方法
        def pearson(self, rating1, rating2):
            sum_xy = 0
            sum_x = 0
            sum_y = 0
            sum_x2 = 0
            sum_y2 = 0
            n = 0
            for key in rating1:
                if key in rating2:
                    n += 1
                    x = rating1[key]
                    y = rating2[key]
                    sum_xy += x * y
                    sum_x += x
                    sum_y += y
                    sum_x2 += pow(x, 2)
                    sum_y2 += pow(y, 2)
            if n == 0:
                return 0
            
            #皮尔逊相关系数计算公式 
            denominator = sqrt(sum_x2 - pow(sum_x, 2) / n)  * sqrt(sum_y2 - pow(sum_y, 2) / n)
            if denominator == 0:
                return 0
            else:
                return (sum_xy - (sum_x * sum_y) / n) / denominator
        
        def computeNearestNeighbor(self, username):
            distances = []
            for instance in self.data:
                if instance != username:
                    distance = self.fn(self.data[username],self.data[instance])
                    distances.append((instance, distance))
    
            distances.sort(key=lambda artistTuple: artistTuple[1],reverse=True)
            return distances
        
        #推荐算法的主体函数
        def recommend(self, user):
            #定义一个字典,用来存储推荐的书单和分数
            recommendations = {}
            #计算出user与所有其他用户的相似度,返回一个list
            nearest = self.computeNearestNeighbor(user)
            # print nearest
            
            userRatings = self.data[user]
    #         print userRatings
            totalDistance = 0.0
            #得住最近的k个近邻的总距离
            for i in range(self.k):
                totalDistance += nearest[i][1]
            if totalDistance==0.0:
                totalDistance=1.0
                
            #将与user最相近的k个人中user没有看过的书推荐给user,并且这里又做了一个分数的计算排名
            for i in range(self.k):
                
                #第i个人的与user的相似度,转换到[0,1]之间
                weight = nearest[i][1] / totalDistance
                
                #第i个人的name
                name = nearest[i][0]
    
                #第i个用户看过的书和相应的打分
                neighborRatings = self.data[name]
    
                for artist in neighborRatings:
                    if not artist in userRatings:
                        if artist not in recommendations:
                            recommendations[artist] = (neighborRatings[artist] * weight)
                        else:
                            recommendations[artist] = (recommendations[artist]+ neighborRatings[artist] * weight)
    
            recommendations = list(recommendations.items())
            recommendations = [(self.convertProductID2name(k), v)for (k, v) in recommendations]
            
            #做了一个排序
            recommendations.sort(key=lambda artistTuple: artistTuple[1], reverse = True)
    
            return recommendations[:self.n],nearest
     
    def adjustrecommend(id):
        bookid_list = []
        r = recommender(users)
        k,nearuser = r.recommend("%s" % id)
        for i in range(len(k)):
            bookid_list.append(k[i][0])
        return bookid_list,nearuser[:15]        #bookid_list推荐书籍的id,nearuser[:15]最近邻的15个用户

     

    数据集的格式如下(点击下载 时间太久了,数据集丢失,抱歉):

     

    程序调用:

    bookid_list,near_list = adjustrecommend("changanamei")
    print ("bookid_list:",bookid_list)
    print ("near_list:",near_list)

    运行结果:

     

    五:基于物品的协同过滤算法的实现

    参考项亮的《推荐系统实战》结合上例中的数据进行算法实现

    #-*-coding:utf-8-*-
    
    '''
    Created on 2016-5-30
    
    @author: thinkgamer
    '''
    import math
    
    class ItemBasedCF:
        def __init__(self,train_file):
            self.train_file = train_file
            self.readData()
        def readData(self):
            #读取文件,并生成用户-物品的评分表和测试集
            self.train = dict()     #用户-物品的评分表
            for line in open(self.train_file):
                # user,item,score = line.strip().split(",")
                user,score,item = line.strip().split(",")
                self.train.setdefault(user,{})
                self.train[user][item] = int(float(score))
    
        def ItemSimilarity(self):
            #建立物品-物品的共现矩阵
            C = dict()  #物品-物品的共现矩阵
            N = dict()  #物品被多少个不同用户购买
            for user,items in self.train.items():
                for i in items.keys():
                    N.setdefault(i,0)
                    N[i] += 1
                    C.setdefault(i,{})
                    for j in items.keys():
                        if i == j : continue
                        C[i].setdefault(j,0)
                        C[i][j] += 1
            #计算相似度矩阵
            self.W = dict()
            for i,related_items in C.items():
                self.W.setdefault(i,{})
                for j,cij in related_items.items():
                    self.W[i][j] = cij / (math.sqrt(N[i] * N[j]))
            return self.W
    
        #给用户user推荐,前K个相关用户
        def Recommend(self,user,K=3,N=10):
            rank = dict()
            action_item = self.train[user]     #用户user产生过行为的item和评分
            for item,score in action_item.items():
                for j,wj in sorted(self.W[item].items(),key=lambda x:x[1],reverse=True)[0:K]:
                    if j in action_item.keys():
                        continue
                    rank.setdefault(j,0)
                    rank[j] += score * wj
            return dict(sorted(rank.items(),key=lambda x:x[1],reverse=True)[0:N])
        
    #声明一个ItemBased推荐的对象    
    Item = ItemBasedCF("uid_score_bid")
    Item.ItemSimilarity()
    recommedDic = Item.Recommend("xiyuweilan")
    for k,v in recommedDic.iteritems():
        print k,"\t",v

    运行结果:

     

    1080309     8.18161438413
    1119522     11.8165100292
    1040104     7.92927319995
    1254588     12.8331124639
    1082138     7.72409411532
    3131626     11.3426906217
    26669243     6.96972128519
    26305561     6.24816554216
    26384985     6.36064881658
    1085799     8.20314297616

     

    展开全文
  • 协同过滤算法源码

    热门讨论 2011-12-12 16:34:45
    基于项目(Item-based)协同过滤算法源码 可用于个性化推荐 参加卓越亚马逊商品推荐
  • 协同过滤算法是信息推荐的一种重要方式,提供了协同过滤算法的代码库
  • 针对离散评分不能合理表达用户观点和传统协同过滤算法存在稀疏性等问题,借鉴年龄模糊模型,提出了梯形模糊评分模型。该模型将离散评分模糊化为梯形模糊数,考虑了评分模糊性和信息量,通过梯形模糊数来计算用户...
  • 推荐算法,协同过滤算法
  • 介绍了C#实现协同过滤算法的实例代码,有需要的朋友可以参考一下
  • 当下使用协同过滤算法计算的推荐系统到处可见,例如淘宝,京东,当当等电商网站,当你在网站上购买或者浏览了某些商品从而被其收集了相对应的数据,下次你在次浏览该网站的时候就会发现,他会根据你之前的购买/浏览...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 33,188
精华内容 13,275
关键字:

协同过滤算法