Google矩阵及PageRank的求解方法

　1. Google矩阵　

　假设有A,B,C,D,E五个网页，其中

　　　　1)A网页有链接指向B,C,D

　　　　2)B网页有链接指向A,E

　　　　3)C网页有链接指向A,E

　　　　4)D网页有链接指向C

　　　　5)E网页有链接指向A,C

　　请写出这个网页链接结构的Google矩阵

　


这样，我们就得到了Google的初始矩阵L（也有资料叫这转移矩阵）。

PageRank的求解

　得到初始矩阵后，我们就可以得到PR值，当只有a概率的用户会点击网页链接，剩下(1-a)概率的用户会跳到无关的页面上去，而访问的页面恰好是这5个页面中A的概率只有(1-a)/5（a是阻尼系数，Google取a等于0.85），所以真正的Google矩阵

　



　

于是得到q（n)=G*q(n-1),特征向量q的初始值为值为1的5*1矩阵，直到q（n)=q(n-1)，q(n)就是PageRank的值。

编程实现此PageRank的计算（Java）

package com.zzg.math;

public class PageRank {

    /**
     * 矩阵g乘以矩阵p

     * @param g
     * @param p
     * @return 矩阵g乘以矩阵p的结果矩阵
     */
    private static double[] multiMatrix(double[][] g, double[] p){
        double[] multiResult = new double[p.length];
        for(int i=0; i<g.length; i++){
            double rowResult = 0.0f;
            for(int j=0; j<g.length; j++){
                rowResult+=g[i][j]*p[j];    
            }
            multiResult[i] = rowResult;
        }
        return multiResult;
    }

    /**
     * 根据初始矩阵计算真正的Google矩阵
     * @param 初始矩阵
     * @param weight
     * @param oneMatrix
     * @return 真正的Google矩阵
     */
    private static void getGoogleMatrix(double[][] transitionMatrix, double weight){

        //transitionMatrix*weight   
        for(int i=0; i<transitionMatrix.length; i++){
            for(int j=0; j<transitionMatrix.length; j++){
                transitionMatrix[i][j] *= weight;
                transitionMatrix[i][j] += (1-weight)/transitionMatrix.length;
            }
        }        
    }

    /**
     * 如果pageRankN=pageRankN_1,返回true；否则，返回false

     * @param pageRankN
     * @param pageRankN_1
     * @return
     */
    private static boolean compareMatrix(double[] pageRankN, double[] pageRankN_1){
        for(int i=0; i<pageRankN.length; i++){
            if(pageRankN[i]-pageRankN_1[i]>0.0000001){
                return false;
            }
        }
        return true;
    }

    /**
     *
     * @param args
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        double[][] transitionMatrix={{0,1/2f,1/2f,0,1/2f},{1/3f,0,0,0,0},{1/3f,0,0,1f,1/2f},{1/3f,0,0,0,0},{0,1/2f,1/2f,0,0}};//初始矩阵
        double[] p={1,1,1,1,1}; 
        double weight = 0.85f; //a的值

        //真正的Google矩阵
        getGoogleMatrix(transitionMatrix, weight);

        //输出看一下
//        for(int i=0; i<transitionMatrix.length; i++){
//            for(int j=0; j<transitionMatrix.length; j++){
//              System.out.print(transitionMatrix[i][j]);
//              System.out.print("  ");
//            }
//            System.out.println();
//        }        

        //q（n)=G*q(n-1),如果q(n)=q(n-1),q(n)是PageRank
        double[] pageRank = multiMatrix(transitionMatrix, p);
        while(!compareMatrix(pageRank, p)){
            p = pageRank;
            pageRank = multiMatrix(transitionMatrix, p);
        }

        for(int i=0; i<pageRank.length; i++){
            System.out.println(pageRank[i]);   
        }
    }

}

输出结果：

1.4308440997406415

0.5554058455846969

1.4542437907845167

0.5554058455846969

1.0041011330680263