"The PageRank Citation Ranking: Bringing Order to the Web"读后感+单线程pagerank算法实现

 

1. 论文原文

 

The PageRank Citation Ranking: Bringing Order to the Web.

 

Page, Lawrence and Brin, Sergey and Motwani, Rajeev and Winograd, Terry (1999) The PageRank Citation Ranking: Bringing Order to the Web. Technical Report. Stanford InfoLab.

 

在几天的集中时间里，拜读了google创始人佩奇和布林的关于pagerank的经典文章，收获颇多。在第2部分介绍了我理解的PageRank原理，第3部分具体写几点感受。附录部分是自己实现了一个单线程的PageRank算法的C++源码。

 

2. PageRank原理介绍

 

1) pagerank要解决的问题

 

将互联网从一个全局的观念上，根据链接关系对网页的重要性进行一个更加贴近于用户兴趣和注意的分数刻画。

 

2) pagerank算法基本思想

 

将互联网的网页看成是一个图的节点，网页之间的链接作为图的有向边，对整个网页进行递归定义：

 

有更多pagerank值高的入链网页的pagerank更高；更高pagerank值网页的出链的网页pagerank值更高。

 

3) pagerank具体形式

 

pagerank的算法公式是如下：

 

 

 

其中表示的是网页的pagerank值，是一个规范化的常数，表示的是的入链集合，表示的是的出链的个数。

 

从这个定义可以看出 2 )中所叙述的递归概念。幸运的是我们可以证明在给定一个不退化初始值时，这个迭代过程是收敛的。

 

Pagerank算法要应付两个问题：

 

a) 网页没有出链的情况

 

论文中把这种链接称为“dangling links”，这种链接还存在两种可能：一是这个网页确实没有外链（出链），比如pdf文档；二是下载的网页数目有限，导致一些外链没有被下载。处理这种链接的方式是在计算pagerank是去掉这样的链接，注意是迭代的去掉，因为可能有的网页链接去掉之后，指向这个页面的网页也将成为dangling link，当计算完pagerank后，再根据指向其的页面pagerank恢复计算即可，当然，同样也是迭代计算。论文的作者表示这样的操作不会对结果有很大的影响。

 

b) 网页存在循环指向的子集合

 

有少量的页面集合或者是单个网页存在循环指向问题，如下面的图。

 

 

 

图1 soso和google的rank sink

 

 

 

图2 baidu的rank sink

 

在图1中soso和google形成了循环指向，并且只有入链，没有出链；在图2中，baidu自己形成了这样的循环指向，这样的现象论文中成为rank sink。Rank sink将影响模型迭代，只积累权值而不释放。解决这个问题的方法是引入一个排名源：

 

 

 

这里的即是一个排名源，是一个在web网页上相对于排名源的向量。这个因子的加入可以用作者提出的随机游走模型进行解释。

 

4)  随机游走模型

 

将互联网网页看成是一个大的图结构，那么用户的访问顺序是沿着外链完全随机的方式访问，但是以的概率分布用户不沿着链接访问而是随机的选取一个页面（用户gets bored），这样当遇到rank sink的时候可以不一直的永远停留在循环里面。这样的方式从用户访问的角度解释了的作用，更加符合用户的客观行为。后面可以看到，除了有防止rank sink的功能，还有别的作用，即个性化的pagerank。

 

5) 收敛性质

 

Pagerank迭代收敛在3.22亿的link集合上用了52次，而在这一半的数据上是45次，作者认为互联网的图结构的收敛速度大约线性于logn。作者用expander-like graph解释了收敛速度的原因。

 

6) pagerank的应用

 

a) 评估web流量

 

b) 反向链接的预测

 

c) 用户导航

 

d) 其他：比如反向链排序

 

3. 读后感

 

1)  pagerank算法的形式是简单的，经典就是经典，这就是吴军博士说的数学之美吧。

 

2)  在pagerank出现之前，其实业界的学者早就注意到了网页链接对于网页排名的重要性，并试图通过各种方式应用其中，但总体不成系统，没有找到真正的规律。

 

3)  论文中作者说提出了pagerank理论，然后实现了一个基于pagerank算法的名叫google的搜索引擎，当时读到这，简直难以抑制激动，读过很多论文里面介绍完理论都会实现自己的一个小系统，没想到真的能有系统能够在日后如此闪耀。我想在当时他们二位也不会预料到google能有以后这样的成功吧。但是不得不佩服二位作者的理论功夫，同时倚仗良好的商业天赋，并抓住了互联网革命的大好机会，最终成就了今天的google。

 

当然，如今pagerank早已经不是搜索引擎对于网页重要性的最佳估计，并且其作用在不断弱化。各种各样的影响因素被计算在内，如何组织这些因素成为目前搜索引擎排序的最大问题。

 

附录

/*Copyright (c) 2013.
* All Rights Reserved.
* Author: laohaizi
*/

#include <iostream>
#include <string>
#include <fstream>
#include <iomanip>
#include <vector>
#include <map>
#include <set>
#include <stdlib.h>
#include <stdio.h>

using namespace std;

#define DAMP_FACTOR 0.85 //dangming factor 
#define PAGERANK_THRESHOLD 1e-5

//page info structure
struct PAGE_INFO
{
    double pagerank;
    string doc_id;
    string url;
    int f_num;//forward num
    int b_num;//backward num
    vector<int> b_f_no;//the pages no point to this
    vector<string> f_url;//forward url
};

//page_info vector
vector<PAGE_INFO> page_info;
int page_info_num = 0;

//map for url to page_info no for computing backward information
map<string, int> url_page;

//vector to record dangling links
vector<int> dangling_link_flag;

/*void MakeUrlPages(string url, int num)
{
    if(map.count(url)==0)
    {
        vector<int> temp_page_no;
        temp_page_no.insert(num);
        url_pages.insert(url,temp_page_no);
    }
    else
    {
        url_pages[url].insert(num);
    }
}*/

//scan page file one pass to record url_page_no
void ScanPageFile(const char *page_file)
{
    cout<<"Starting scaning page file..."<<endl;
    ifstream filein(page_file);
    if(!filein)
    {
        cout<<"Open page file error."<<endl;
        exit(-1);
    }
    string line;
    string html;
    int pos_beg=0,pos_end=0;
    int num = 0;
    while(getline(filein,line))
    {
        pos_beg = 0;
        
        //split \t three parts of one line:doc_id, url, html
        pos_end = line.find("\t");
        if(pos_end==string::npos)
        {
            cout<<num<<":line format is wrong."<<endl;
            continue;
        }
        pos_beg = pos_end+1;
        pos_end = line.find("\t",pos_beg);
        if(pos_end==string::npos)
        {
            url_page.insert(map<string,int>::value_type (line.substr(pos_beg), num));
        }
        else url_page.insert(pair<string,int>(line.substr(pos_beg, pos_end-pos_beg), num));
        num ++;
    }
    cout<<"Finished scaning page file."<<endl;
}

//scan original page to obtain web_info
void ScanPage(const char *page_file)
{
    cout<<"Starting scaning page..."<<endl;
    ifstream filein(page_file);
    if(!filein)
    {
        cout<<"Open page file error."<<endl;
        exit(-1);
    }
        string line;
    string html;
    int pos_beg=0,pos_end=0;
    int num = 0;
    while(getline(filein,line))
    {
       // cout<<num<<":begin scaning line..."<<endl;
        PAGE_INFO temp_page_info;
        temp_page_info.pagerank = -1;
        temp_page_info.f_num = 0;
        temp_page_info.b_num = 0;
        pos_beg = 0;
        
        //split \t three parts of one line:doc_id, url, html
        pos_end = line.find("\t");
        if(pos_end==string::npos)
        {
            cout<<num<<":line format is wrong."<<endl;
            continue;
        }
       // cout<<num<<":begin to doc_id..."<<endl;
        temp_page_info.doc_id = line.substr(pos_beg, pos_end-pos_beg);
        //MakeUrlPages(page_web_info.doc_id,num);
        //num ++;
        dangling_link_flag.push_back(1);
        pos_beg = pos_end+1;
        pos_end = line.find("\t",pos_beg);
        if(pos_end==string::npos)
        {
            temp_page_info.f_num = 0;
            temp_page_info.url = line.substr(pos_beg);
           // url_page.insert(map<string,int>::value_type (temp_page_info.url,num));
            page_info.push_back(temp_page_info);
            num ++;
            continue;
        }
       // cout<<num<<":begin assign url..."<<endl;
       // temp_page_info.url = line.substr(pos_beg, pos_end-pos_beg);
        url_page.insert(pair<string,int>(temp_page_info.url, num));
        num ++;
        pos_beg = pos_end+1;
        pos_end = line.find("\t",pos_beg);
        set<string> temp_url;//uniq the url in one page
       // cout<<num-1<<":begin to create temp_url..."<<endl;
        while(pos_end!=string::npos)
        {
            //temp_web_info.f_num ++;
            if(url_page.count(line.substr(pos_beg,pos_end-pos_beg))!=0)
                temp_url.insert(line.substr(pos_beg, pos_end-pos_beg));
            //temp_web_info.f_url.insert(line.substr(pos_beg, pos_end));
            pos_beg = pos_end+1;
            pos_end = line.find("\t",pos_beg);
        }
        //temp_web_info.f_num ++;
        //temp_web_info.f_url.insert(line.substr(pos_beg));
        if(url_page.count(line.substr(pos_beg))!=0)
            temp_url.insert(line.substr(pos_beg));
       // cout<<num-1<<":begin temp_url to f_url..."<<endl;
        for(set<string>::iterator it = temp_url.begin();it!=temp_url.end();it++)
        {
            temp_page_info.f_num ++;
            temp_page_info.f_url.push_back(*it);
        }
       // cout<<num-1<<":temp_url to f_url success."<<endl;
        page_info.push_back(temp_page_info);
       // cout<<"doc_id: "<<page_info[num-1].doc_id<<"\t";
       // cout<<"url: "<<page_info[num-1].url<<endl;
       // cout<<"forward url:\t";
       // for(int j=0;j<page_info[num-1].f_num;j++)
       // {
       //     cout<<page_info[num-1].f_url[j]<<"\t";
       // }
       // cout<<endl;
       // cout<<"backward url(doc_id):\t";
       // for(int j=0;j<page_info[num-1].b_num;j++)
       // {
       //     cout<<page_info[num-1].b_f_no[j]<<"\t";
       // }
       // cout<<endl;

    }
    filein.close();
    //cout<<"begin scan page_info and map:url_page"<<endl;
    //scan the page_iofo and map:url_page to complete backward info
    for(int i=0;i<page_info.size();i++)
    {
        for(int j=0;j<page_info[i].f_url.size();j++)
        {
            if(url_page.count(page_info[i].f_url[j])!=0)
            {
                // for(int k=0;k<url_page[page_info[i].f_url[j]].size();k++)
                {
                    //cout<<page_info[url_page[page_info[i].f_url[j]]].b_num<<endl;
                    //cout<<j<<":"<<url_page[page_info[i].f_url[j]]<<endl;
                    page_info[url_page[page_info[i].f_url[j]]].b_f_no.push_back(i);
                    page_info[url_page[page_info[i].f_url[j]]].b_num ++;
                }
             }
        }
    }
    //cout<<num-1<<":finish scan page_info adn map:url_page"<<endl;

    page_info_num = page_info.size();
    cout<<"Page Number: "<<page_info.size()<<endl;
    cout<<"Scan page finished."<<endl;
    /*for(int i=0;i<page_info.size();i++)
    {
        cout<<"doc_id: "<<page_info[i].doc_id<<"\t";
        cout<<"url: "<<page_info[i].url<<endl;
        cout<<"forward url:\t";
        for(int j=0;j<page_info[i].f_num;j++)
        {
            cout<<page_info[i].f_url[j]<<"\t";
        }
        cout<<endl;
        cout<<"backward url(doc_id):\t";
        for(int j=0;j<page_info[i].b_num;j++)
        {
            cout<<page_info[i].b_f_no[j]<<"\t";
        }
        cout<<endl;
    }*/
}

//remove the dangling links
void RemoveDanglingLinks()
{
    cout<<"Start removing dangling links..."<<endl;
    int dangling_link_num = 0;
    int f = 1;
    while(f==1)//iterate remove dangling links
    {
        f = 0;
        for(int i=0;i<page_info.size();i++)
        {
            if(page_info[i].f_num==0&&dangling_link_flag[i]==1)//dangling links
            {
                dangling_link_num ++;
                f = 1;
                dangling_link_flag[i] = 0;
                for(int j=0;j<page_info[i].b_num;j++)
                {
                    page_info[page_info[i].b_f_no[j]].f_num --;
                }
            }
        }
    }
    cout<<"Dangling Links Number: "<<dangling_link_num<<endl;
    cout<<"Remove dangling links finished."<<endl;
}

//compute the pagerank
void ComputePageRank()
{
    cout<<"Start computing pagerank..."<<endl;

    double d = DAMP_FACTOR;//damping factor
    double epslon = PAGERANK_THRESHOLD;
    double delta = 1.0;

    //assign initial pagerank value
    for(int i=0;i<page_info.size();i++)
    {
        if(dangling_link_flag[i]==1)
        {
            page_info[i].pagerank = 1.0;
        }
        else
        {
            page_info[i].pagerank = -1.0;
        }
    }

    //cout<<"Assign initial pagerank value success."<<endl;

    //temp pagerank value to iterator
    //vector 2 pagerank for not assign back every iteration
    vector<double> pagerank[2];
    for(int i=0;i<page_info.size();i++)
    {
        pagerank[0].push_back(page_info[i].pagerank);
        pagerank[1].push_back(page_info[i].pagerank);
    }
    int x = 0,y = 1;

    //cout<<"Assign 2 temp vector for iteration success."<<endl; 
    //start iteration
    int iter_num = 0;
    while(delta>epslon)
    {
        delta = 0.0;
        for(int i=0;i<page_info.size();i++)
        {
            pagerank[x][i] = 0.0;
            if(dangling_link_flag[i]==1)//not compute danglilng links
            {
                for(int j=0;j<page_info[i].b_num;j++)
                {
                    pagerank[x][i] += (1-d)/page_info_num + d*pagerank[y][page_info[i].b_f_no[j]]/page_info[page_info[i].b_f_no[j]].f_num;
                }
                if(pagerank[x][i]-pagerank[y][i]<0)
                {
                    delta += pagerank[y][i]-pagerank[x][i];
                }
                else
                {
                    delta += pagerank[x][i]-pagerank[y][i];
                }
            }
        }
        //exchang x and y
        int temp = x;
        x = y;
        y = temp;
        if(delta<0)delta = -delta;
        iter_num ++;
        cout<<"iter "<<iter_num<<" diff: "<<delta<<endl;
    }
    //final to assign to page_info.pagerank
    for(int i=0;i<page_info.size();i++)
    {
        if(dangling_link_flag[i]==1)
        {
            page_info[i].pagerank = pagerank[y][i];
        }
    }
    cout<<"Compute pagerank finished."<<endl;
}
//Recover dangling links, namely compute the dangling links's pagerank
void RecoverDanglingLinks()
{
    cout<<"Start recovering dangling links..."<<endl;
    int flag = 1;
    while(flag==1)//iterate recover dangling links
    {
        flag = 0;
        for(int i=0;i<page_info.size();i++)
        {
            if(dangling_link_flag[i]==0)//dangling links
            {
                flag = 1;
                int dangling_link_backward_flag = 1;
                for(int j=0;j<page_info[i].b_f_no.size();j++)
                {
                    if(page_info[page_info[i].b_f_no[j]].pagerank<0)
                    {
                        dangling_link_backward_flag = 0;
                        break;
                    }
                }
                if(dangling_link_backward_flag==1)//all backward page of this dangling link is already having pagerank 
                {
                    double i_pagerank = 0.0;
                    for(int j =0;j<page_info[i].b_f_no.size();j++)
                    {
                        i_pagerank += page_info[page_info[i].b_f_no[j]].pagerank;
                    }
                    page_info[i].pagerank = i_pagerank;
                    dangling_link_flag[i] = 1;//use this to flag recover dangling link
                }
            }
        }
    }
    cout<<"Recover dangling links finished."<<endl;
}
//output the pagerank info to file
void OutputPageRank(const char *pagerank_file)
{
    cout<<"Start outputing pagerank result to file."<<endl;
    ofstream fileout(pagerank_file);
    if(!fileout)
    {
        cout<<"open output file: pagerank_file error."<<endl;
        exit(-1);
    }
    for(int i=0;i<page_info.size();i++)
    {
        fileout<<page_info[i].doc_id<<"\t"<<setprecision(5)<<page_info[i].pagerank<<endl;
    }
    fileout.close();
    cout<<"Output pagerank result to file finished."<<endl;
}

int main(int args, char *argv[])
{
    if(args!=3)
    {
        cout<<"program para wrong. The first para is input page_file, and the second para is output_pagerank file."<<endl;
        exit(-1);
    }

    const char *input_page_file = argv[1];
    const char *output_pagerank_file = argv[2];
   
    ScanPageFile(input_page_file);

    ScanPage(input_page_file);
    
    RemoveDanglingLinks();
    
    ComputePageRank();
    
    RecoverDanglingLinks();
    
    OutputPageRank(output_pagerank_file);

    return 0;
}