基于用户的协同过滤和皮尔逊相关系数

2012 年 11 月 05 日 isnowfy algorithm, web

frameborder="0" hspace="0" marginheight="0" marginwidth="0" scrolling="no" tabindex="0" vspace="0" width="100%" id="I0_1448430258843" name="I0_1448430258843" src="https://apis.google.com/u/0/se/0/_/+1/fastbutton?usegapi=1&size=small&origin=http%3A%2F%2Fwww.isnowfy.com&url=http%3A%2F%2Fwww.isnowfy.com%2Fcollaborative-filtering-and-pearson-correlation-coefficient%2F&gsrc=3p&ic=1&jsh=m%3B%2F_%2Fscs%2Fapps-static%2F_%2Fjs%2Fk%3Doz.gapi.zh_CN.3ZnptyJyqBA.O%2Fm%3D__features__%2Fam%3DAQ%2Frt%3Dj%2Fd%3D1%2Ft%3Dzcms%2Frs%3DAGLTcCO9UqyjRGXu4wYeaqGuwkJDGsrriQ#_methods=onPlusOne%2C_ready%2C_close%2C_open%2C_resizeMe%2C_renderstart%2Concircled%2Cdrefresh%2Cerefresh&id=I0_1448430258843&parent=http%3A%2F%2Fwww.isnowfy.com&pfname=&rpctoken=13579790" data-gapiattached="true" title="+1" style="border-width: 0px; border-style: none; margin: 0px; padding: 0px; vertical-align: baseline; position: static; top: 0px; width: 70px; left: 0px; visibility: visible; height: 15px; background: transparent;">

Go to comment

推荐系统的经典算法就是协同过滤了,协同过滤算法有两种,一种是基于物品的,一种是基于用户的。从很多实验效果来看基于用户的协同过滤算法要好于基于物品的协同过滤算法。

那么简单来说基于物品的协同过滤算法是说我会推荐给你和你喜欢物品相似的物品,而基于用户的协同过滤算法是说我把和你相似的用户喜欢的东西推荐给你。为什么叫协同过滤呢,因为我们是利用用户的群体行为来作这些相似操作的。计算物品的相似的时候我们比较不同的人来对他打分来比较,同样计算用户相关性的时候我们就是通过对比他们对相同物品打分的相关度来计算的,我们来举个例子。

--------+--------+--------+--------+--------+|   X    |    Y   |    Z   |    R   |
--------+--------+--------+--------+--------+a   |   5    |    4   |    1   |    5   |
--------+--------+--------+--------+--------+b   |   4    |    3   |    1   |    ?   |
--------+--------+--------+--------+--------+c   |   2    |    2   |    5   |    1   |
--------+--------+--------+--------+--------+

a用户给X物品打了5分,Y打了4分,Z打了1分,同理b用户和c用户,那么很容易看到a用户和b用户非常相似,但是b用户没有看过R物品,那么我们就可以把和b用户很相似的a用户打分很高的R物品推荐给b用户,这就是基于用户的协同过滤。

ok,回到我们协同过滤的算法上,现在我们知道了基于用户的协同过滤需要比较用户的相关性,那么如何计算这个相关性呢,于是我们可以利用两个用户对于相同物品的评分来计算相关性。对于a,b用户而言,他们都对XYZ物品进行了评价,那么,a我们可以表示为(5,4,1),b可以表示为(4,3,1),经典的算法是计算把他们看作是两个向量,并计算两个向量间的夹角,或者说计算向量夹角的cosine值来比较,于是a和b的相关性为。

sim=5∗4+4∗3+1∗152+42+12√∗42+32+12√

这个值介于-1到1之间,越大,说明相关性越大。

到这里似乎cosine还是不错的,但是考虑这么个问题,用于用户间的差异,d用户可能喜欢打高分,e用户喜欢打低分,f用户喜欢乱打分。

--------+--------+--------+--------+|   X    |    Y   |    Z   |
--------+--------+--------+--------+d   |   4    |    4   |    5   |
--------+--------+--------+--------+e   |   1    |    1   |    2   |
--------+--------+--------+--------+f   |   4    |    1   |    5   |
--------+--------+--------+--------+

很显然用户d和e对于作品评价的趋势是一样的,所以应该认为d和e更相似,但是用cosine计算出来的只能是d和f更相似。于是就有皮尔逊相关系数(pearson correlation coefficient)。

sim=∑ni=1(Xi−Xˉ)∗(Yi−Yˉ)∑ni=1(Xi−Xˉ)2√∗∑ni=1(Yi−Yˉ)2√

pearson其实做的事情就是先把两个向量都减去他们的平均值,然后再计算cosine值。

最后让我们用实际数据来对比下cosine和pearson的效果吧。这里我们用到了movielens的数据,数据是1000多个用户对于1700个movie的超过10000的评分数据,数据已经分成多组,并且每组都是80%的训练数据和20%的测试数据。我们在训练数据上对于每个用户找出和他相似的20个用户,然后把当前用户没看过的这些用户的movie的评分加权和,然后选出5篇分数最高的作为推荐,然后把推荐出来的在测试数据上计算一个得分。代码如下。

  1. # -*- coding: utf-8 -*-
  2. import heapq
  3. name = 'u1'
  4. def get(f):
  5. ret = {}
  6. for i in open(f, 'r'):
  7. tmp = map(int, filter(lambda x:len(x)>0, i.split('\t')))
  8. if tmp[0] not in ret:
  9. ret[tmp[0]] = {}
  10. ret[tmp[0]][tmp[1]] = tmp[2]
  11. return ret
  12. def cosine(item1, item2):
  13. sum0 = sum(map(lambda x:x[0]*x[1], zip(item1, item2)))
  14. sum1 = sum(map(lambda x:x*x, item1))
  15. sum2 = sum(map(lambda x:x*x, item2))
  16. return sum0/(sum1**0.5)/(sum2**0.5)
  17. def pearson(item1, item2):
  18. a1 = (sum(item1)+0.0)/len(item1)
  19. a2 = (sum(item2)+0.0)/len(item2)
  20. sum0 = sum(map(lambda x:(x[0]-a1)*(x[1]-a2), zip(item1, item2)))
  21. sum1 = sum(map(lambda x:(x-a1)*(x-a1), item1))
  22. sum2 = sum(map(lambda x:(x-a2)*(x-a2), item2))
  23. if not sum1 or not sum2:
  24. return cosine(item1, item2)
  25. return sum0/(sum1**0.5)/(sum2**0.5)
  26. def get_sim(user):
  27. ret = {}
  28. for i in user:
  29. ret[i] = {}
  30. for j in user:
  31. itemset = set(user[i].keys())&set(user[j].keys())
  32. tmp1 = map(lambda x:x[1], filter(lambda y:y[0] in itemset, sorted(user[i].items())))
  33. tmp2 = map(lambda x:x[1], filter(lambda y:y[0] in itemset, sorted(user[j].items())))
  34. if not len(tmp1):
  35. ret[i][j] = 0
  36. else:
  37. ret[i][j] = cosine(tmp1, tmp2)
  38. return ret
  39. def get_re(user, sim):
  40. ret = {}
  41. for i in user:
  42. tmp = filter(lambda y:y[0]!=i, heapq.nlargest(20, sim[i].items(), key=lambda x:x[1]))
  43. tmp_res = {}
  44. for j in tmp:
  45. for k in user[j[0]]:
  46. if k in user[i]:
  47. continue
  48. if k not in tmp_res:
  49. tmp_res[k] = 0
  50. tmp_res[k] += j[1]*user[j[0]][k]
  51. ret[i] = map(lambda x:x[0], heapq.nlargest(5, tmp_res.items(), key=lambda x:x[1]))
  52. return ret
  53. def test_score(test_data, re):
  54. score = 0
  55. for i in test_data:
  56. u = test_data[i]
  57. r = re[i]
  58. tmp = 0
  59. for i in r:
  60. if i in u:
  61. tmp += u[i]
  62. score += (tmp+0.0)/len(r)
  63. return score/len(test_data)
  64. def main():
  65. data1 = get(name+'.base')
  66. data2 = get(name+'.test')
  67. sim = get_sim(data1)
  68. re = get_re(data1, sim)
  69. print test_score(data2, re)
  70. if __name__ == '__main__':
  71. main()

最后我们看看结果。

从图中可以看出,用pearson来计算用户相似来进行推荐的话,效果还是要好于cosine的。所以说基于用户的协同过滤还是用pearson来做用户相似是比较好的阿。

基于用户的协同过滤和皮尔逊相关系数相关推荐

  1. 基于用户的协同过滤(user-based collaborative filtering)

    姓名:wagsyang  日期:星期四, 08. 十二月 2016 03:25下午 简介 本文是集体智慧编程一书的学习笔记. 一个协作型过滤算法通常是对一大群人进行搜索,并从中找出与我们品味相近的一小 ...

  2. C++实现基于用户的协同过滤大数据电影推荐系统

    <大数据计算及应用> [推荐系统]实验报告 目录 <大数据计算及应用> 1 [推荐系统]实验报告 1 [实验相关统计信息] 1 (1)统计用户数量:19835. 1 [实验原理 ...

  3. 基于内容的推荐java代码_三种推荐算法简介:基于用户的协同过滤、基于物品的协同过滤、基于内容的推荐...

    1.推荐算法 1.1.协同过滤 协同过滤是目前应用最广泛的推荐算法,它仅仅通过了解用户与物品之间的关系进行推荐,而根本不会考虑到物品本身的属性. 可分成两类: 1.基于用户(user-based)的协 ...

  4. (数据挖掘-入门-1)基于用户的协同过滤之最近邻

    主要内容: 1.什么是基于用户的协同过滤 2.python实现 1.什么是基于用户协同过滤: 协同过滤:Collaborative Filtering,一般用于推荐系统,如京东,亚马逊等电商网站上的& ...

  5. 推荐系统--基于用户的协同过滤算法

    1.         概述 和搜索引擎一样,推荐系统是为了帮助人们更快速的获得对自己有用的信息. 和搜索引擎不同,推荐系统是人们被动的获取,由系统根据用户行为或其他的信息推荐给用户的,儿搜索引擎是用户 ...

  6. 【知识发现】基于用户的协同过滤推荐算法python实现

    1.协同过滤推荐算法分为两类,分别是基于用户的协同过滤算法(user-based collaboratIve filtering),和基于物品的协同过滤算法(item-based collaborat ...

  7. 协同过滤:基于用户的协同过滤itemCF

    基于用户的协同过滤算法也被称为最近邻协同过滤或KNN (K.Nearest-Neighbor,K最近邻算法).其核心思想就是,首先根据相似度计算出目标用户的邻居集合,然后用邻居用户评分的加权组合来为目 ...

  8. 【推荐系统】基于用户的协同过滤算法

    基于用户的协同过滤算法 基础算法 在一个在线个性化推荐系统中,当一个用户A需要个性化推荐时,可以先找到和他有相似兴趣的其他用户,然后把那些用户喜欢的.而用户A没有听说过的物品推荐给A.这种方法称为基于 ...

  9. UserCF,基于用户的协同过滤算法

    转载自   UserCF,基于用户的协同过滤算法 UserCF:User  Collaboration   Filter,基于用户的协同过滤 算法核心思想:在一个在线推荐系统中,当用户A需要个性化推荐 ...

最新文章

  1. 【UGV】小车一些图片 麦轮版小车
  2. loginButton.setOnClickListener(this);这里为什么要用this呢?
  3. 艾伟_转载:使用Lambda表达式编写递归函数
  4. 【CodeForces - 270A】Fancy Fence (几何,思维,水题)
  5. Android 监控网络状态
  6. 磁力链转bt种子 python_实战Python实现BT种子转化为磁力链接
  7. 经典而常用的配乐和背景音乐合集(上)
  8. 《Introduction To Modern Cryptography》读书笔记一
  9. IP地址、子网掩码、网络地址之间相关的计算
  10. 【IT互联网系列】什么是网关?网关的作用是什么?看完不懂,你捶我
  11. 智遥工作流为Sap报工时(实例)
  12. Ubuntu 开机未登录用户前自动连接wifi
  13. 仿小米商城SpringBoot+Vue全栈项目开发实战文档
  14. 辅警小丁同志 灵宝西站派出所第一警务区赵桥
  15. MPEG PS流格式
  16. STM32 定时器编码器模式时,如何理解编码器计数
  17. 免费的静态网页托管_如何使用自动管道免费托管静态站点
  18. css好看的图片投影,css3常见好看的投影效果_css3阴影box-shadow高大上用法
  19. 安全绳使用方法图解_安全带和安全绳的正确使用方法
  20. LA 4413 Triangle Hazard 梅涅劳斯定理的应用

热门文章

  1. linux如何编辑启动项,Ubuntu 11.04 启动项的修改
  2. 使用Ubuntu挂载NTFS格式分区
  3. acwing算法题--分组背包问题
  4. leetcode算法题--最佳买卖股票时机含冷冻期★
  5. java http连接_Java中通过方法创建一个http连接并请求(服务器间进行通信)
  6. redis 查看key的有效期_你经常忽略的Redis常见面试题,精选给你整理
  7. angular集成websocket_Angular + Websocket
  8. go同一个目录下的go文件里面不能有多个package
  9. Kubernetes 安装
  10. 动态修改easyui datagrid 列宽度