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，请不要见怪哈。

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

 package com.cgtz.main;
  /**
 * @author Administrator
 *
 */public class HelloWorld {
      public static void main(String[] args) {
              //原始矩阵
              double[][] sMatrix=new double[][]{
                      {0,  0.5,  0.5,   0,  0.5},
                      {0.25 ,  0  ,  0  ,  0,   0},
                      {0.25 ,  0   , 0  ,  1,  0.5},
                      {0.25 ,  0.5,  0.5  ,0 ,  0},
                      {0.25  , 0  ,  0  ,  0 ,  0}
              };
              //单位矩阵
              double uMatrix[][]=new double[][]{
                      {1,  0,  0,   0,  0},
                      {0 ,  1  ,  0  ,  0,   0},
                      {0 ,  0   , 1  ,  0,  0},
                      {0 ,  0,  0  ,1 ,  0},
                      {0  , 0  ,  0  ,  0 ,  1}
              };
              double qMatrix[]=new double[]{
                      1,1,1,1,1
              };
              double gMatrix[][]=new double[5][5];
              gMatrix=getGMatrix(sMatrix,uMatrix);
              printMatrix(gMatrix);
              double[] lastQMatrix=getLastQMatrix(gMatrix,  qMatrix);
              for (int i = 0; i < lastQMatrix.length; i++) {
                 System.out.println(lastQMatrix[i]);
             }
      }
      //计数，可以调试时使用，也可以用来确定整个迭代的循环进行了多少次
     static int count=0;
     //整个方法，就是得出最后的排名向量，是一个核心的方法
     private static double[] getLastQMatrix(double[][] gMatrix, double[] qMatrix) {
     //每迭代一次，count的次数就加上一。
          count+=1;
     /**
       创建一个临时的数组，次数组的的长度和需要线性变换的向量的长度相同，此数组可以当成数学中的一个向量。
       整个temp向量的作用就是用来存放最原始的特征向量，以便与最终的向量进行比较
     */
         double[] temp=new double[qMatrix.length];
         //
         for (int i = 0; i < temp.length; i++) {
             temp[i]=qMatrix[i];
         }
         System.out.println("temp[1]---1:"+temp[0]);
     /**
        下面的嵌套的for循环，是用来q特征向量与G矩阵进行相乘，特征新的向量，需要说明的是，这里其实就是五维空间到五维空间的映射。
     */
         for (int i = 0; i < gMatrix.length; i++) {
             double newQ=0;
             for (int j = 0; j < qMatrix.length; j++) {
                 double tempValue=gMatrix[i][j]*qMatrix[j];
                 System.out.println("tempValue:"+tempValue);
                 newQ+=tempValue;
             }
             qMatrix[i]=newQ;
             System.out.println("----------------");
         }
     //打印出迭代一次之后得到新的排名向量
         System.out.println("第"+count+"次迭代得到的矩阵。。。");
         for (int s = 0; s < temp.length; s++) {
             System.out.println("qMatrix---"+qMatrix[s]);
         }
           /**
             下面的运算，是求两个向量之间的距离，
             公式为：
        */
         double distace=0;
         double sDistance=0;
         System.out.println("temp.length:"+temp.length);
         System.out.println("temp[1]---2:"+temp[0]);
         for (int i = 0; i < temp.length; i++) {
             double x=temp[i]-qMatrix[i];
             double x2=java.lang.StrictMath.pow(x,2);
             sDistance+=x2;
         }
         distace=Math.sqrt(sDistance);
         System.out.println("第"+count+"次迭代sDistance:"+sDistance);
     //这里自己任意取一个合适的distance来确定多大距离时停止迭代
         if(distace<0.0001){
             for (int i = 0; i < temp.length; i++) {
                 System.out.println(qMatrix[i]);
             }
             return qMatrix;
         }else{
             getLastQMatrix(gMatrix,qMatrix);
         }
         return qMatrix;
     }
     public static void printMatrix(double[][] matrix){
          for (int i = 0; i < matrix.length; i++) {
             for (int j = 0; j < matrix.length; j++) {
                 System.out.print(matrix[i][j]+"--");
             }
             System.out.println();
          }
      }
      private static double[][] getGMatrix(double[][] sMatrix, double[][] uMatrix) {
          double gMatrix[][]=new double[5][5];
          for(int i=0;i<sMatrix.length;i++){
              for(int j=0;j<sMatrix.length;j++){
                  gMatrix[i][j]=(0.5)*sMatrix[i][j];
              }
          }
          for(int i=0;i<uMatrix.length;i++){
              for(int j=0;j<uMatrix.length;j++){
                  gMatrix[i][j]+=(0.5)*(0.2)*uMatrix[i][j];
              }
          }
         return gMatrix;

     }

 }

计算的结果：

第14次迭代得到的矩阵。。。

qMatrix—2.8735992663233403E-5

qMatrix—4.620592012663504E-6

qMatrix—3.089895664396781E-5

qMatrix—1.604329405333448E-5

qMatrix—4.620592012663504E-6

由结果可知，c的网页的排名最高。

3，当网页数量较多的时候，就使用分布式计算的方案：

原理见下面的图片：

每个网页乘以对应的分向量，而后变得到了新的q，即为变换之后的q

4,Google的分词技术：