PageRank的java实现

一个网络(有向带权图)中节点u的PageRank的计算公式：

PR(u)表示节点u的PageRank值，d为衰减因子(damping factor)或阻尼系数,一般取d=0.85,N为网络中的节点总数，nb(u)表示节点u的所有邻居节点的集合，d(v)表示节点v的出度(如果是无向图，就是度)，w(u,v)表示节点v的边<u,v>所占的权重(如果对于无权图或者认为每条边的权重都一样，那么w(u,v)=1),PR(v)表示节点v的PageRank值。

由此可以看出要算出节点u的PR值需要先知道它的每个邻居节点的PR值，似乎是个递归的过程。其实初始状态下，可以给每个节点的PR值都赋值为一个任意正数，例如1，然后通过上述公式不断迭代计算更新每个节点的PR值，数学证明，最终每个节点的PR值都会收敛到一个稳定的PR值（初值PR不同，最终的PR值也不同，但最后各节点之间PR的大小排名不因初值而改变）。编程时如何确定某个节点u的PR值已经收敛？如果这次的PR值与上次的PR值相差很小的时候就可以认为收敛了。很小是多小？越小越好，但不要太小，免得迭代次数太多浪费时间，可取10的-4或-5次方。

PageRank的数学原理的详细说明，可参考：

深入浅出PageRank算法

PageRank on undirected and weighted graph

《集体智慧编程》上的例子：

 

Java实现代码：

Program.java:

package dd.lt;

import dd.lt.entity.Node;

public class Program
{
    //计算每个节点的PageRank值
    public static void CalcPageRank(ArrayList<Node> graph)
    {
        double distance = 0.00001;
        double d = 0.85;// damping factor
        double common = (1 - d) / graph.size();
        while (true)
        {
            for (Node n : graph)
            {
                double sum = 0.0;
                for (int nodeId : n.getNeighbors())
                {
                    Node nb = getNodeById(nodeId,graph);
                    sum += nb.getPR() / nb.getDegree();
                }
                double newPR = common + d * sum;
                //如果尚未收敛，赋新值，否则结束迭代
                if (Math.abs(n.getPR() - newPR) > distance)
                    n.setPR(newPR);
                else
                    return;
            }
        }
    }

    public static Node getNodeById(int nodeId,ArrayList<Node> graph)
    {
        for(Node n:graph)
        {
            if (n.nodeId==nodeId)
                return n;
        }
        return null;
    }
    
    
    public static ArrayList<Node> buildGraph()
    {
        ArrayList<Node> graph = new ArrayList<Node>();//图以节点集合形式来表示
        //加载数据，组装好图结构
        ....
        return graph;
    }
    
    public static void main(String[] args)
    {
        ArrayList<Node> graph = buildGraph();
        CalcPageRank(graph);
        for(Node n:graph)
        {
            System.out.println("PageRank of %d is %.2f",n.nodeId,n.getPR());
        }
    }
}

 

Node.java:

package dd.lt.entity;

import java.util.ArrayList;

public class Node implements Comparable<Node>
{
    public int nodeId;
    private ArrayList<Integer> neighbors = new ArrayList<Integer>();//以邻接表的形式表示图结构【无向图】
    private double pr=1; //每个节点的初始PageRank值设为1
    public Node(int nodeId)
    {
        this.nodeId = nodeId;
    }

    public int getDegree()
    {
        return this.neighbors.size();
    }
    
    public ArrayList<Integer> getNeighbors()
    {
        return this.neighbors;
    }
    public void setNeighbors(ArrayList<Integer> neighbors)
    {
        this.neighbors=neighbors;
    }

    public double getPR()
    {
        return pr;
    }
    public void setPR(double val)
    {
        this.pr=val;
    }
    
    // 按PageRank值排序
    public int compareTo(Node anotherNode)
    {
        if (this.neighbors != null && anotherNode.neighbors != null)
        {
            // 降序排列
            if (anotherNode.getPR() >this.getPR())
                return 1;
            else if (anotherNode.getPR() <this.getPR())
                return -1;
            else 
                return 0;
            // 升序排列
            // return this.getPR()-anotherNode.getPR();
        }
        return 0;
    }
}