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;
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;
}
}