Google的PageRank及其Map-reduce应用（日志五）

上一篇：Hadoop的安装（日志四）

1，算法的原理解释：

如下图所示，G就是传说中的谷歌矩阵，这个矩阵是n*n型号的，n表示共计有n个网页。

如矩阵中所示：

11位置处的元素，是表示第一个网页指向的第一个网页的比例值。

12元素，第二个网页指向第一个网页的比例值。

所谓的比例值，这个名称是我给取的，意思就是指向的链接占据所有链接的比例，例如，1网页指向了2,3,4网页，那么其1指向2网页的比例值就为1/3。

按照上面的原理，解析所有的链接，便得到了一个Google矩阵。

Google论文中有：

下面的公式之中α的取值范围是0在1之间任意取值，用于更加方便和精准的计算收敛的q。

至于q=Gq,由于G本身是一个矩阵，所以这个公式其实就是一个线性变换的过程。初始的时候，q可以取任意的值，例如（1,1,1,1,1），但需要注意的是，其维数，一定是要和网页个数相同的。不断对q进行线性变换，最终变换得到的q会收敛于q,而这个就是q表示最终排名的向量。

以上便是上面算法的所有原理解释。

2，例题（及其java实现）：

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

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

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

4)D网页有链接指向C

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

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

B 手动或编程计算这5个页面的PR值

Google矩阵：

代码实现：这个代码实现，是本人一步步探索出来的，给出的注释比较详细，应该好理解，但其中还所许多需要优化的地方，看上去依旧很low b，请不要见怪哈。

主要原理，就是利用二维数组实现矩阵的运算，搞定了这个，一切就简单。

  1 package com.cgtz.main;
  2   3 /**
  4 * @author Administrator
  5 *
  6 */public class HelloWorld {
  7      public static void main(String[] args) {
  8              //原始矩阵
  9              double[][] sMatrix=new double[][]{
 10                      {0,  0.5,  0.5,   0,  0.5},
 11                      {0.25 ,  0  ,  0  ,  0,   0},
 12                      {0.25 ,  0   , 0  ,  1,  0.5},
 13                      {0.25 ,  0.5,  0.5  ,0 ,  0},
 14                      {0.25  , 0  ,  0  ,  0 ,  0}
 15              };
 16              //单位矩阵
 17              double uMatrix[][]=new double[][]{
 18                      {1,  0,  0,   0,  0},
 19                      {0 ,  1  ,  0  ,  0,   0},
 20                      {0 ,  0   , 1  ,  0,  0},
 21                      {0 ,  0,  0  ,1 ,  0},
 22                      {0  , 0  ,  0  ,  0 ,  1}
 23              };
 24              double qMatrix[]=new double[]{
 25                      1,1,1,1,1
 26              };           
 27              double gMatrix[][]=new double[5][5];
 28              gMatrix=getGMatrix(sMatrix,uMatrix);
 29              printMatrix(gMatrix);
 30              double[] lastQMatrix=getLastQMatrix(gMatrix,  qMatrix);
 31              for (int i = 0; i < lastQMatrix.length; i++) {
 32                 System.out.println(lastQMatrix[i]);
 33             }                         
 34      }
 35      //计数，可以调试时使用，也可以用来确定整个迭代的循环进行了多少次
 36     static int count=0;
 37     //整个方法，就是得出最后的排名向量，是一个核心的方法
 38     private static double[] getLastQMatrix(double[][] gMatrix, double[] qMatrix) {
 39     //每迭代一次，count的次数就加上一。
 40          count+=1;
 41     /**
 42       创建一个临时的数组，次数组的的长度和需要线性变换的向量的长度相同，此数组可以当成数学中的一个向量。
 43       整个temp向量的作用就是用来存放最原始的特征向量，以便与最终的向量进行比较
 44     */ 
 45         double[] temp=new double[qMatrix.length];
 46         //
 47         for (int i = 0; i < temp.length; i++) {
 48             temp[i]=qMatrix[i];
 49         }
 50         System.out.println("temp[1]---1:"+temp[0]);
 51     /**
 52        下面的嵌套的for循环，是用来q特征向量与G矩阵进行相乘，特征新的向量，需要说明的是，这里其实就是五维空间到五维空间的映射。
 53     */
 54         for (int i = 0; i < gMatrix.length; i++) {
 55             double newQ=0;
 56             for (int j = 0; j < qMatrix.length; j++) {
 57                 double tempValue=gMatrix[i][j]*qMatrix[j];
 58                 System.out.println("tempValue:"+tempValue);
 59                 newQ+=tempValue;           
 60             }
 61             qMatrix[i]=newQ;
 62             System.out.println("----------------");
 63         }
 64     //打印出迭代一次之后得到新的排名向量
 65         System.out.println("第"+count+"次迭代得到的矩阵。。。");
 66         for (int s = 0; s < temp.length; s++) {         
 67             System.out.println("qMatrix---"+qMatrix[s]);
 68         }
 69           /**
 70             下面的运算，是求两个向量之间的距离，
 71             公式为：
 72  73       */
 74         double distace=0;
 75         double sDistance=0;
 76         System.out.println("temp.length:"+temp.length);
 77         System.out.println("temp[1]---2:"+temp[0]);
 78         for (int i = 0; i < temp.length; i++) {
 79             double x=temp[i]-qMatrix[i];
 80             double x2=java.lang.StrictMath.pow(x,2);
 81             sDistance+=x2;
 82         }
 83         distace=Math.sqrt(sDistance);
 84         System.out.println("第"+count+"次迭代sDistance:"+sDistance);
 85     //这里自己任意取一个合适的distance来确定多大距离时停止迭代
 86         if(distace<0.0001){
 87             for (int i = 0; i < temp.length; i++) {
 88                 System.out.println(qMatrix[i]);
 89             }
 90             return qMatrix;         
 91         }else{ 
 92             getLastQMatrix(gMatrix,qMatrix);
 93         }
 94         return qMatrix;
 95     }
 96     public static void printMatrix(double[][] matrix){
 97          for (int i = 0; i < matrix.length; i++) {
 98             for (int j = 0; j < matrix.length; j++) {
 99                 System.out.print(matrix[i][j]+"--");
100             }
101             System.out.println();       
102          }
103      }
104      private static double[][] getGMatrix(double[][] sMatrix, double[][] uMatrix) {
105          double gMatrix[][]=new double[5][5];
106          for(int i=0;i<sMatrix.length;i++){
107              for(int j=0;j<sMatrix.length;j++){
108                  gMatrix[i][j]=(0.5)*sMatrix[i][j];             
109              }           
110          }
111          for(int i=0;i<uMatrix.length;i++){
112              for(int j=0;j<uMatrix.length;j++){
113                  gMatrix[i][j]+=(0.5)*(0.2)*uMatrix[i][j];           
114              }                       
115          }           
116         return gMatrix;
117 
118     }
119 
120 
121 }