第一周：PageRank学习心得--JAVA编程实现

最近复习Hadoop  发现之前很多笔记，贴出来很大家共享下。

Google 矩阵和Page Rank的简单介绍  

                                                                                                                                                                       

　　Page Rank是Google排名算法法则的一部分，是Google用于标识网页的等级/重要性的一种方法，是Google用来衡量一个网站好坏的标准。在揉合了诸如Title标识和Keywords标识等所有其它因素之后，Google通过PageRank来调整结果，使那些更具“等级/重要性”的网页在搜索结果中的排名获得提升，从而提高搜索结果的相关性和质量。其级别从0到10级，10级为满分。PR值越高说明该网页越重要。
    Google的PageRank根据网站的外部链接和内部链接的数量和质量来衡量网站的价值。
    [以上引自：百度百科，详细见http://baike.baidu.com/view/1518.htm，就不多作介绍了]

矩阵概念相关

     相信很多人对于大学的“线性代数”忘记的差不多了；在谷歌矩阵的求解过程中我们要使用到的几个基本的概念：特征向量，矩阵的加法，矩阵的乘法。

    一个矩阵说穿了就是一个二维数组。一个n行m列的矩阵可以乘以一个m行p列的矩阵，得到的结果是一个n行p列的矩阵，其中的第i行第j列位置上的数等于前一个矩阵第i行上的m个数与后一个矩阵第j列上的m个数对应相乘后所有m个乘积的和。比如，下面的算式表示一个2行2列的矩阵乘以2行3列的矩阵，其结果是一个2行3列的矩阵

    如果你忘得差不多了（楼主也是），建议花两三个小时复习下。推荐：http://wenku.baidu.com/view/3d8e80373968011ca30091c0  从第14页（行列式）开始回忆。

    （题外话： 大家都在骂大学应试教育的不合理性，但是在这里我们能发现：错误的是制度本身而不是知识。 对于知识的获得：我学过忘了和我没学过是有质的区别的---欢迎拍砖）

    假如你还是没弄明白特征向量的话，其实可以先掠过的，当作是一个N行1列的矩阵（哈哈本来就是），我们要通过这个矩阵来不停的进行q(n)=G*q(n-1)（G是pangRank矩阵，q是特征向量） 的运算，直到q（n)=q(n-1)，q(n)就是PR的值。

    参考的资料：http://www.cnblogs.com/itTeacher/archive/2013/06/08/3126914.html

用JAVA编程实现PageRank

package com.hadoop;


public class GetPageRank {


        // a是阻尼系数，Google取a等于0.85

        private static float alpha = 0.85f;


        public static void main(String[] args) {


                try {


                        // 转移矩阵

                        float[][] S = { { 0, 0, 0, 0 }, { 0.3333333f, 0, 0, 1 },

                                        { 0.3333333f, 0.5f, 0, 0 }, { 0.3333333f, 0.5f, 1, 0 } };


                        // 初始特征向量

                        float[][] U = { { 1, 1, 1, 1 }, { 1, 1, 1, 1 }, { 1, 1, 1, 1 },

                                        { 1, 1, 1, 1 } };


                        float[][] f1 = multiGeneMatrix(alpha, S);// as

                        float[][] f2 = multiGeneMatrix((1 - alpha) / S[1].length, U);// (1-a)/n*U


                        // 获取pageRank

                        float[][] G = addMatrix(f1, f2);// aS+(1-a)/n*U


                        // 打印矩阵内容

                        printContentOfMatrix(G);


                        // 特征向量

                        float[] pr_cur = { 1f, 1f, 1f, 1f };// result：0.15000004 1.492991

                        // 0.82702124 1.5299894

                        

                        int i = 0;

                        // 求pageRank值  q(n)=G*q(n-1)，直到q（n)=q(n-1)，q(n)就是PR的值。

                        while (true) {

                                float[] pr_next = multiMatrixVector(G, pr_cur);

                                if (compareMatrix(pr_cur, pr_next)) {

                                        System.out.println("总共计算了：" + i + "次");

                                        System.out.println(pr_next[0] + "--" + pr_next[1] + "--"

                                                        + pr_next[2] + "--" + pr_next[3]);

                                        break;

                                } else {

                                        i++;

                                        pr_cur = pr_next;

                                }

                        }

                } catch (Exception e) {

                        System.out.println(e.getMessage());

                }

        }


        // 矩阵与向量相乘

        public static float[] multiMatrixVector(float[][] m, float[] v) {

                float[] rv = null;

                try {

                        rv = new float[v.length];


                        for (int vl = 0; vl < v.length; vl++) {


                                for (int row = 0; row < m.length; row++) {

                                        float one = 0;

                                        for (int col = 0; col < m[1].length; col++) {

                                                one += m[row][col] * v[col];

                                        }

                                        rv[row] = one;

                                }

                        }

                } catch (Exception e) {

                        System.out.println(e.getMessage());

                }

                return rv;

        }


        // 两矩阵相加

        public static float[][] addMatrix(float[][] f1, float[][] f2) {


                float[][] result = null;


                try {

                        result = new float[f1.length][f1[1].length];


                        for (int row = 0; row < f1.length; row++) {

                                for (int col = 0; col < f1[1].length; col++) {

                                        result[row][col] = f1[row][col] + f2[row][col];

                                }

                        }


                } catch (Exception e) {

                }

                return result;

        }


        // 矩阵乘因子

        public static float[][] multiGeneMatrix(float f, float[][] fm) {


                float[][] result = null;

                try {


                        result = new float[fm.length][fm[1].length];


                        for (int row = 0; row < fm.length; row++) {

                                for (int col = 0; col < fm[1].length; col++) {

                                        result[row][col] = fm[row][col] * f;

                                }

                        }


                } catch (Exception e) {

                }

                return result;

        }


        // 打印矩阵内容

        public static void printContentOfMatrix(float[][] f) {

                try {

                        System.out.println("--------------得到的谷歌矩阵如下---------------");

                        for (int row = 0; row < f.length; row++) {

                                for (int col = 0; col < f[1].length; col++) {

                                        System.out.print(f[row][col] + " ");

                                }

                                System.out.println();

                        }

                        System.out

                                        .println("----------------------------------------------");

                } catch (Exception e) {

                        System.out.println(e.getMessage());

                }

        }


        // 比较两个特征向量

        public static boolean compareMatrix(float[] now, float[] next) {

                try {

                        for (int i = 0; i < next.length; i++) {

                                if (next - now > 0.0000001) {

                                        return false;

                                }

                        }

                } catch (Exception e) {

                        System.out.println(e.getMessage());

                }

                return true;

        }


}