PageRank算法简介及Map-Reduce实现

最新推荐文章于 2021-03-31 17:01:01 发布
最新推荐文章于 2021-03-31 17:01:01 发布
阅读量1.6k 收藏 1
点赞数
分类专栏： Hadoop

  • PageRank对网页排名的算法，曾是Google发家致富的法宝。以前虽然有实验过，但理解还是不透彻，这几天又看了一下，这里总结一下PageRank算法的基本原理。

    一、什么是pagerank

    　　PageRank的Page可是认为是网页，表示网页排名，也可以认为是Larry Page(google 产品经理)，因为他是这个算法的发明者之一，还是google CEO（^_^）。PageRank算法计算每一个网页的PageRank值，然后根据这个值的大小对网页的重要性进行排序。它的思想是模拟一个悠闲的上网者，上网者首先随机选择一个网页打开，然后在这个网页上呆了几分钟后，跳转到该网页所指向的链接，这样无所事事、漫无目的地在网页上跳来跳去，PageRank就是估计这个悠闲的上网者分布在各个网页上的概率。

    二、最简单pagerank模型

    　　互联网中的网页可以看出是一个有向图，其中网页是结点，如果网页A有链接到网页B，则存在一条有向边A->B，下面是一个简单的示例：\

    　　这个例子中只有四个网页，如果当前在A网页，那么悠闲的上网者将会各以1/3的概率跳转到B、C、D，这里的3表示A有3条出链，如果一个网页有k条出链，那么跳转任意一个出链上的概率是1/k，同理D到B、C的概率各为1/2，而B到C的概率为0。一般用转移矩阵表示上网者的跳转概率，如果用n表示网页的数目，则转移矩阵M是一个n*n的方阵；如果网页j有k个出链，那么对每一个出链指向的网页i，有M[i][j]=1/k，而其他网页的M[i][j]=0；上面示例图对应的转移矩阵如下：

    \

    　　初试时，假设上网者在每一个网页的概率都是相等的，即1/n，于是初试的概率分布就是一个所有值都为1/n的n维列向量V0，用V0去右乘转移矩阵M，就得到了第一步之后上网者的概率分布向量MV0,（nXn）*(nX1)依然得到一个nX1的矩阵。下面是V1的计算过程：

    \

    　　注意矩阵M中M[i][j]不为0表示用一个链接从j指向i，M的第一行乘以V0，表示累加所有网页到网页A的概率即得到9/24。得到了V1后，再用V1去右乘M得到V2，一直下去，最终V会收敛，即Vn=MV(n-1)，上面的图示例，不断的迭代，最终V=[3/9,2/9,2/9,2/9]'：

    \

      

    三、终止点问题

    　　上述上网者的行为是一个马尔科夫过程的实例，要满足收敛性，需要具备一个条件：

    图是强连通的，即从任意网页可以到达其他任意网页：

    　　互联网上的网页不满足强连通的特性，因为有一些网页不指向任何网页，如果按照上面的计算，上网者到达这样的网页后便走投无路、四顾茫然，导致前面累计得到的转移概率被清零，这样下去，最终的得到的概率分布向量所有元素几乎都为0。假设我们把上面图中C到A的链接丢掉，C变成了一个终止点，得到下面这个图：

    \

    　　对应的转移矩阵为：

    \

    　　连续迭代下去，最终所有元素都为0：　　

    \

    四、陷阱问题

    　　另外一个问题就是陷阱问题，即有些网页不存在指向其他网页的链接，但存在指向自己的链接。比如下面这个图：

    \

    　　上网者跑到C网页后，就像跳进了陷阱，陷入了漩涡，再也不能从C中出来，将最终导致概率分布值全部转移到C上来，这使得其他网页的概率分布值为0，从而整个网页排名就失去了意义。如果按照上面图对应的转移矩阵为：　

    \

    　　不断的迭代下去，就变成了这样：

    \

    五、解决终止点问题和陷阱问题

    　　上面过程，我们忽略了一个问题，那就是上网者是一个悠闲的上网者，而不是一个愚蠢的上网者，我们的上网者是聪明而悠闲，他悠闲，漫无目的，总是随机的选择网页，他聪明，在走到一个终结网页或者一个陷阱网页（比如两个示例中的C），不会傻傻的干着急，他会在浏览器的地址随机输入一个地址，当然这个地址可能又是原来的网页，但这里给了他一个逃离的机会，让他离开这万丈深渊。模拟聪明而又悠闲的上网者，对算法进行改进，每一步，上网者可能都不想看当前网页了，不看当前网页也就不会点击上面的连接，而上悄悄地在地址栏输入另外一个地址，而在地址栏输入而跳转到各个网页的概率是1/n。假设上网者每一步查看当前网页的概率为a，那么他从浏览器地址栏跳转的概率为(1-a)，于是原来的迭代公式转化为：

    \

    　　现在我们来计算带陷阱的网页图的概率分布：

     \

    　　重复迭代下去，得到：

    \

    　　可以看到C虽然占了很大一部分pagerank值，但其他网页页获得的一些值，因此C的链接结构，它的权重确实应该会大些。

    六、用Map-reduce计算Page Rank

    　　上面的演算过程，采用矩阵相乘，不断迭代，直到迭代前后概率分布向量的值变化不大，一般迭代到30次以上就收敛了。真的的web结构的转移矩阵非常大，目前的网页数量已经超过100亿，转移矩阵是100亿*100亿的矩阵，直接按矩阵乘法的计算方法不可行，需要借助Map-Reduce的计算方式来解决。实际上，google发明Map-Reduce最初就是为了分布式计算大规模网页的pagerank，Map-Reduce的pagerank有很多实现方式，我这里计算一种简单的。

    　　考虑转移矩阵是一个很多的稀疏矩阵，我们可以用稀疏矩阵的形式表示，我们把web图中的每一个网页及其链出的网页作为一行，这样第四节中的web图结构用如下方式表示：

    view source print ?
    1. 1 A    B    C    D
    2. 2 B    A    D
    3. 3 C    C
    4. 4 D    B    C

    　　A有三条出链，分布指向A、B、C，实际上，我们爬取的网页结构数据就是这样的。

    　　1、Map阶段

    　　Map操作的每一行，对所有出链发射当前网页概率值的1/k，k是当前网页的出链数，比如对第一行输出<B，1/3*1/4>,<C，1/3*1/4>,<D，1/3*1/4>;

    　　2、Reduce阶段

    　　Reduce操作收集网页id相同的值，累加并按权重计算，pj=a*(p1+p2+...Pm)+(1-a)*1/n，其中m是指向网页j的网页j数，n所有网页数。

    　　思路就是这么简单，但是实践的时候，怎样在Map阶段知道当前行网页的概率值，需要一个单独的文件专门保存上一轮的概率分布值，先进行一次排序，让出链行与概率值按网页id出现在同一Mapper里面，整个流程如下：

    \

    　　这样进行一次迭代相当于需要两次MapReduce，但第一次的MapReduce只是简单的排序，不需要任何操作，用python调用Hadoop的Streaming.

    　　SortMappert.py代码如下:

    view source print ?
    1. 1 #!/bin/python
    2. 2 '''Mapper for sort'''
    3. 3 import sys
    4. 4 for line in sys.stdin:
    5. 5      print line.strip()

    　　SortReducer.py也是一样

    view source print ?
    1. 1 #!/bin/python
    2. 2 '''Reducer for sort'''
    3. 3 import sys
    4. 4 for line in sys.stdin:
    5. 5       print line.strip()

    　　PageRankMapper.py代码:

    view source print ?
    01. 1 ''' mapper of pangerank algorithm'''
    02. 2 import sys
    03. 3 id1 = id2 = None
    04. 4 heros = value = None
    05. 5 count1 = count2 = 0
    06. 6
    07. 7 for line in sys.stdin:
    08. 8     data = line.strip().split('  ')
    09. 9     if len(data) == 3 and data[1] == 'a':# This is the pangerank value
    10. 10         count1 += 1
    11. 11         if count1 >= 2:
    12. 12             print '%s    %s' % (id1,0.0)
    13. 13            
    14. 14         id1 = data[0]
    15. 15         value = float(data[2])
    16. 16     else:#This the link relation
    17. 17         id2 = data[0]
    18. 18         heros = data[1:]
    19. 19     if id1 == id2 and id1:
    20. 20         v = value / len(heros)
    21. 21         for hero in heros:
    22. 22             print '%s    %s' % (hero,v)
    23. 23         print '%s    %s' % (id1,0.0)
    24. 24         id1 = id2 = None
    25. 25         count1 = 0

    　　PageRankReducer.py代码:

    view source print ?
    01. 1 ''' reducer of pagerank algorithm'''
    02. 2 import sys
    03. 3 last = None
    04. 4 values = 0.0
    05. 5 alpha = 0.8
    06. 6 N = 4# Size of the web pages
    07. 7 for line in sys.stdin:
    08. 8     data = line.strip().split('  ')
    09. 9     hero,value = data[0],float(data[1])
    10. 10     if data[0] != last:
    11. 11         if last:
    12. 12             values = alpha * values + (1 - alpha) / N
    13. 13             print '%s    a   %s' % (last,values)
    14. 14         last = data[0]
    15. 15         values = value
    16. 16     else:
    17. 17         values += value #accumulate the page rank value
    18. 18 if last:
    19. 19     values = alpha * values + (1 - alpha) / N
    20. 20     print '%s    a   %s' % (last,values)

    　　在linux下模仿Map-Reduce的过程：

    view source print ?
    01. 1 #!/bin/bash
    02. 2 PATH=/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin:/usr/games
    03. 3 export PATH
    04. 4 max=10
    05. 5 for i in `seq 1 $max`
    06. 6 do
    07. 7     echo '$i'
    08. 8     cat links.txt pangerank.value > tmp.txt
    09. 9     cat tmp.txt |sort|python PageRankMapper.py |sort|python PageRankReducer.py >pangerank.value
    10. 10 done

    　　这个代码不用改动就可以直接在hadoop上跑起来。调用hadoop命令： 

    view source print ?
    01. 1 #!/bin/bash
    02. 2
    03. 3 #sort
    04. 4 mapper=SortMapper.py
    05. 5 reducer=SortReducer.py
    06. 6 input='yours HDFS dir'/links.txt
    07. 7 input='yours HDFS dir'/pagerank.value
    08. 8 output='yours HDFS dir'/tmp.txt
    09. 9
    10. 10 hadoop jar contrib/streaming/hadoop-*streaming*.jar
    11. 11     -mapper /home/hduser/mapper.py
    12. 12     -reducer /home/hduser/reducer.py
    13. 13     -input $input
    14. 14     -output $output
    15. 15    
    16. 16    
    17. 17 #Caculator PageRank
    18. 18 mapper=PageRankMapper.py
    19. 19 reducer=PageRankReducer.py
    20. 20 input='yours HDFS dir'/tmp.txt
    21. 21 output='yours HDFS dir'/pagerank.value
    22. 22
    23. 23 hadoop jar contrib/streaming/hadoop-*streaming*.jar
    24. 24     -mapper /home/hduser/mapper.py
    25. 25     -reducer /home/hduser/reducer.py
    26. 26     -input $input
    27. 27     -output $output

    　　关于使用python操作hadoop可以查看参考文献。python代码写得浓浓的C味，望海涵！

    　　第四步中带环的陷阱图，迭代40次，权值a取0.8，计算结果如下：

    view source print ?
    01. 1 A            B                C                D
    02. 2 0.15    0.216666666667    0.416666666667    0.216666666667   
    03. 3 0.136666666666    0.176666666666    0.51    0.176666666666   
    04. 4 0.120666666666    0.157111111111    0.565111111111    0.157111111111   
    05. 5 0.112844444444    0.145022222222    0.597111111111    0.145022222222   
    06. 6 0.108008888889    0.138100740741    0.615789629629    0.138100740741   
    07. 7 0.105240296296    0.134042666667    0.62667437037    0.134042666667   
    08. 8 0.103617066667    0.131681145679    0.633020641975    0.131681145679   
    09. 9 0.102672458272    0.130303676049    0.636720189629    0.130303676049   
    10. 10 0.10212147042    0.129500792625    0.638876944329    0.129500792625   
    11. 11 0.10180031705    0.129032709162    0.640134264625    0.129032709162   
    12. 12 0.101613083665    0.128759834878    0.640867246578    0.128759834878   
    13. 13 0.101503933951    0.128600756262    0.641294553524    0.128600756262   
    14. 14 0.101440302505    0.128508018225    0.641543661044    0.128508018225   
    15. 15 0.10140320729    0.128453954625    0.64168888346    0.128453954625   
    16. 16 0.10138158185    0.128422437127    0.641773543895    0.128422437127   
    17. 17 0.101368974851    0.128404063344    0.64182289846    0.128404063344   
    18. 18 0.101361625338    0.128393351965    0.641851670733    0.128393351965   
    19. 19 0.101357340786    0.128387107543    0.641868444129    0.128387107543   
    20. 20 0.101354843017    0.128383467227    0.64187822253    0.128383467227   
    21. 21 0.101353386891    0.128381345029    0.641883923053    0.128381345029   
    22. 22 0.101352538012    0.128380107849    0.641887246292    0.128380107849   
    23. 23 0.10135204314    0.128379386609    0.641889183643    0.128379386609   
    24. 24 0.101351754644    0.128378966148    0.641890313062    0.128378966148   
    25. 25 0.101351586459    0.128378721031    0.641890971481    0.128378721031   
    26. 26 0.101351488412    0.128378578135    0.64189135532    0.128378578135   
    27. 27 0.101351431254    0.128378494831    0.641891579087    0.128378494831   
    28. 28 0.101351397932    0.128378446267    0.641891709536    0.128378446267   
    29. 29 0.101351378507    0.128378417955    0.641891785584    0.128378417955   
    30. 30 0.101351367182    0.128378401451    0.641891829918    0.128378401451   
    31. 31 0.10135136058    0.128378391829    0.641891855763    0.128378391829   
    32. 32 0.101351356732    0.12837838622    0.64189187083    0.12837838622   
    33. 33 0.101351354488    0.12837838295    0.641891879614    0.12837838295   
    34. 34 0.10135135318    0.128378381043    0.641891884735    0.128378381043   
    35. 35 0.101351352417    0.128378379932    0.64189188772    0.128378379932   
    36. 36 0.101351351973    0.128378379284    0.64189188946    0.128378379284   
    37. 37 0.101351351714    0.128378378906    0.641891890474    0.128378378906   
    38. 38 0.101351351562    0.128378378686    0.641891891065    0.128378378686   
    39. 39 0.101351351474    0.128378378558    0.64189189141    0.128378378558   
    40. 40 0.101351351423    0.128378378483    0.641891891611    0.128378378483   
    41. 41 0.101351351393    0.128378378439    0.641891891728    0.128378378439

    　　可以看到pagerank值已经基本趋于稳定，并与第四步的分数表示一致。

    　　PageRank的简介就介绍到这里了，如果想深入可以参考原论文或者下面的参考文献

     

延伸阅读：


小木偶-嗯嗯
关注
专栏目录
[笔记]PageRank算法简介及Map-Reduce实现
cangdu的专栏
01-04 400
文章来源 这一篇文章对原理做了很浅显易懂的介绍， 这里补充几点。 Markov状态转移矩阵可以直接写成平时上课的时候说的那种形式，也就是 M[i][j]代表从状态i转移到状态j的概率 这时，将初始状态概率变成行向量， 并且左乘即可， 相当于转置了。 这个图中， 初始向量分布的文件， 之所有要有中间那个a， 我觉得是为了保证这个文件的行在表示连接关系的那一行之后， 比
PageRank算法详解与Map-Reduce实现详解
在PageRank算法的实现中，可以利用Map-Reduce将计算任务分解到多台机器上并行执行，提高效率。在Map阶段，处理每个网页的PageRank更新，而在Reduce阶段，汇总这些更新以获得全局的PageRank值。这种并行化处理使得...
使用Map-Reduce对大规模图进行排名和半监督分类
11-19
标题中的“使用Map-Reduce对大规模图进行排名和半监督分类”是指利用MapReduce编程模型处理大规模图数据，实现图的排序（如PageRank）和半监督学习中的分类任务。MapReduce是由Google提出的一种分布式计算框架，适用...
hadoop-page-rank:MC6007 - Hadoop PageRank map-reduce
07-10
这个项目"MC6007 - Hadoop PageRank map-reduce"提供了学习和实践分布式计算、PageRank算法以及Hadoop MapReduce框架的好机会。通过分析和运行这个项目，你可以深入理解分布式系统如何处理大数据，并掌握如何用Java...
PageRank算法的mapreduce实现
09-02
PageRank算法的MapReduce实现
MapReduce框架中PageRank算法的简单实现
zxxapple的专栏
02-15 217
主要实现思想在另一篇博客中已经提到：   具体实现每次迭代包括两个Job 第一个分散各个节点的PR值   第二个用于将dangling节点的PR值分散到其它节点   主要包括5个类 PageRankNode：图中的节点类-代表一个页面 PageRankJob：实现分散各个节点的PR值的类 DistributionPRMass：实现dangling节点的PR值分散到其它节点的Jo...
MapReduce 之PageRank 算法概述
01-16
这篇文档详细介绍了pagerank的起源及算法过程，带有各部分的注释，能使小白看懂
【MapReduce】使用MapReduce实现PageRank算法
HR的博客
03-31 3132
使用MapReduce实现PageRank算法PageRank算法的介绍PageRank是什么？方法原理算法过程算法公式算法的缺点简单模型代码的实现流程数据信息第一计数类自定义类，来解决存储每一行数据Mapper阶段Reduce阶段Driver阶段结果 PageRank算法的介绍 PageRank是什么？ PageRank（网页排名）是Google提出的算法，用于衡量特定网页相对于搜索引擎索引中的其他网页而言的重要程度,是 Google 对网页重要性、价值的评估。是Google创始人拉里·佩奇和谢尔盖·
使用MapReduce实现PageRank算法
红豆和绿豆的博客
01-18 3423
首先简单的介绍一下PageRank的算法 PageRank首先是Google 公司提出的网页排名的算法，主要就是将网页的中的连接看成入度和出度的这么一个矩阵。然后对这个排名的矩阵不断的迭代，知道达到收敛为止 主要的公式 PR(u)=求和v 属于Bu  （PR（v）/L(v)） Bu是所有网网页指向u集合，v是其中的一个指向u页面的元素，L（v）页面v的出度 这个公式会造成网页的排名下降以
Hadoop学习——(5) MapReduce实现PageRank
机器学习，大数据
04-09 2546
文章目录1. PageRank原理1.1 简单例子1.2 终止点与陷阱2. MapReduce实现2.1 数据准备2.2 Map阶段2.3 Reduce阶段2.4 main函数2.5 运行结果Reference 1. PageRank原理 PageRank是一种计算网页重要程度的算法，算法根据网页之间的链接，为每个网页计算一个PageRank值，值越大表明网页越重要，在搜索结果中排在更前面的位置。...
MapReduce实现的PageRank原理
coco_ethan的专栏
11-25 181
PageRank手工计算得出的值见帖子 http://f.dataguru.cn/thread-17158-1-1.html 这个值有助于我们验证下面MR计算是不是正确 首先假设有两个节点A和B 原始矩阵如tiger老师的幻灯片第九页 a=1 网页1和2保存在节点A上 网页3和4保存在节点B上 由于A在A上很容易计算1和2的出链 根据MR的本地运算的思想，网页1和2的处理必在A上完成，B...
基于MapReduce实现PageRank算法
Wuyikkk的博客
02-23 884
一、什么是PageRank PageRank，又称网页排名、谷歌左侧排名，是一种由搜索引擎根据网页之间相互的超链接计算的技术，而作为网页排名的要素之一，以Google公司创办人拉里·佩奇（Larry Page）之姓来命名。Google用它来体现网页的相关性和重要性，在搜索引擎优化操作中是经常被用来评估网页优化的成效因素之一。 二、实现公式 对于一个页面A，那么它的PR值为： R(A) 是页面A的PR值 PR(Ti)是页面Ti的PR值，在这里，页面Ti是指向A的所有页面中的某个页面 C(Ti)是
PageRank算法MapReduce实现
weixin_33970449的博客
06-20 238
如果你现在需要计算网页的排名只有4一：数据如下面的： baidu 10.00 google,sina,nefu google 10.00 baidu sina 10.00 google nefu 10.00 sina,google 1. baidu  存在三个外链接 2.google 存在1个外链接 3.sina 存在1个外链接 4.nefu. 存在2个外链接 由数据能够看出：...
MapReduce之PageRank
zhangdy12307的博客
11-01 735
MapReduce之PageRank MapReduce之PageRank简化实现   PageRank算法是用来衡量评估网页重要性或者等级的算法，Google据此表示网页的PR值，从0级到10级，级数越高说明该网页越重要。  互联网上的各个网页之间的连接关系我们都可以看成是一个有向图，对于任何网页，他们的PR值都可以表示为: Gamma公式展示 Γ(z)=∫0∞tz−1e−tdt . \Gamma(z) = \int_0^\infty t^{z-1}e^{-t}dt\,. Γ(z)=∫0∞​tz−1e−t
mapreduce 实现pagerank
weixin_30883271的博客
10-29 120
输入格式： A　　1　　B,C,D　　　B　　1　　C,Dmap:　　 B　　A　　1/3　 　C　　A　　1/3　 　D　　A　　1/3　 　A　　|B,C,D　 　C　　B　　1/2　 　D　　B　　1/2　 　B　　|C,Dreduce:　　　B　　(1-0.85)+0.85*1/3　　C,D 　　　C　　(1-0.85)+0.85*5/6　　 D　　...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值