Mapreduce -- PageRank

PageRank 简单理解为网页排名，但是网页是根据什么排名的，接下来就简单介绍一下。

举例：

假设网页 A 的内容中有网页 B，C 和 D 的链接，并且 A 的 PageRank的值为0.25。

那接下里我们就可以计算在网页 A 中的其他网页的PageRank的值了。我们拿网页 B 来进行说明，

在网页 A 中的网页 B 的 PageRank 为 0.25 * (1/n) 其中n为网页 A 中网页链接数，结果则为 0.25*(1/3)。

可以简单理解为A的PageRank被B，C 和 D 平分了，B分到了0.25的三分之一。

然后将所有网页中的关于网页B的pagerank值求出来，就是网页B真实的pagerank了。

但是上面的例子没有考虑到如下的特殊情况：

1 网页A中只有指向自己的网页链接。

2 网页A中没有任何链接。

如果出现以上情况，会导致pagerank结果不准确。

所以出现了下面的公式：

result = sum * n + (1-n)/N

sum 为上面计算出来的，如网页B在所有网页中的pagerank值的总和。

n 可以理解为停留在当前网页继续进行网页跳转浏览的概率

1-n 可以理解为不访问当前网页的任何链接，从浏览器的地址栏输入，转去其他网页的概率。

N 为网页的数量

下面介绍通过MapReduce实现PageRank

简单的流程分析：

Map

取一行数据进行说明

A    B    C    D

网页A中有网页B,C,D的链接;

刚开始给网页A一个默认的pagerank值，然后根据这个值计算其他网页链接在网页A中的PageRank。处理后的数据如下：

A    0.25    B    C    D
B    0.25*(/)
C    0.25*(/)
D    0.25*(/)

Reduce

然后通过 Reduce 计算出各个网页在其他网页中的 PageRank 的总和 sum，然后代入公式计算实际的PageRank，并更新 A 0.25 B C D 中的数据，这里将0.25更新为计算出来真实的 PageRank。

重复计算各个网页的 PageRank 的值，直到 PageRank 的结果收敛，值趋于稳定。

A    0.25    B    C    D  =>A    ?    B    C    D

测试数据：

A    B       C       D
B    A       D
C    C
D    B       C

测试代码：

RunJob.java

 import org.apache.hadoop.conf.Configuration;
 import org.apache.hadoop.fs.FileSystem;
 import org.apache.hadoop.fs.Path;
 import org.apache.hadoop.io.Text;
 import org.apache.hadoop.mapreduce.Job;
 import org.apache.hadoop.mapreduce.Mapper;
 import org.apache.hadoop.mapreduce.Reducer;
 import org.apache.hadoop.mapreduce.lib.input.FileInputFormat;
 import org.apache.hadoop.mapreduce.lib.input.KeyValueTextInputFormat;
 import org.apache.hadoop.mapreduce.lib.output.FileOutputFormat;

 import java.io.IOException;

 /**
  * Created by Edward on 2016/7/13.
  */
 public class RunJob {

     public static enum ValueEnum{
         CLOSURE_VALUE;
     }

     public static void main(String[] args)
     {

         //access hdfs's user
         System.setProperty("HADOOP_USER_NAME","root");

         Configuration conf = new Configuration();
         conf.set("fs.defaultFS", "hdfs://node1:8020");

         try {
             int i = 0;
             while(true) {
                 i++;
                 conf.setInt("count", i);

                 FileSystem fs = FileSystem.get(conf);
                 Job job = Job.getInstance(conf);
                 job.setJarByClass(RunJob.class);
                 job.setMapperClass(MyMapper.class);
                 job.setReducerClass(MyReducer.class);

                 //需要指定 map out 的 key 和 value
                 job.setOutputKeyClass(Text.class);
                 job.setOutputValueClass(Text.class);

                 //设置输入类的
                 job.setInputFormatClass(KeyValueTextInputFormat.class);
                 if(i==1)
                     FileInputFormat.addInputPath(job, new Path("/test/pagerank/input"));
                 else
                     FileInputFormat.addInputPath(job, new Path("/test/pagerank/output/pr"+(i-1)));

                 Path path = new Path("/test/pagerank/output/pr"+i);
                 if (fs.exists(path))//如果目录存在，则删除目录
                 {
                     fs.delete(path, true);
                 }
                 FileOutputFormat.setOutputPath(job, path);

                 boolean b = job.waitForCompletion(true);
                 if (b) {
                     long closure =job.getCounters().findCounter(ValueEnum.CLOSURE_VALUE).getValue();
                     double avg= closure/4000.0;//计算收敛的平均值，浮动小于0.001则认为收敛
                     System.out.println("执行第"+i+"次, closure="+closure+",avg="+avg);
                     if(avg < 0.001){
                         System.out.println("总共执行了"+i+"次，之后收敛");
                         break;
                     }
                 }
             }

         } catch (Exception e) {
             e.printStackTrace();
         }
     }

     public static class MyMapper extends Mapper<Text, Text, Text, Text> {
         @Override
         protected void map(Text key, Text value, Context context) throws IOException, InterruptedException {
             AdjacentNodes adjacentNodes  = new AdjacentNodes();
             int count = context.getConfiguration().getInt("count", 1);

             if(count == 1)
             {
                 AdjacentNodes firstAdj = new AdjacentNodes();
                 firstAdj.setValue(1.0);
                 firstAdj.setNodes(value.toString().split("\t"));
                 adjacentNodes = firstAdj;
             }
             else
             {
                 //格式化 value: 1.0 B C D
                 adjacentNodes.formatInfo(value.toString());
             }
             //A 1.0 B C D
             context.write(key, new Text(adjacentNodes.toString()));

             double pagerank = adjacentNodes.getValue()/adjacentNodes.getNum();
             for(int i=0; i<adjacentNodes.getNum(); i++)
             {
                 String node = adjacentNodes.getNodes()[i];
                 //B 0.333
                 context.write(new Text(node), new Text(pagerank+""));
             }
         }
     }

     public static class MyReducer extends Reducer<Text, Text, Text, Text> {
         @Override
         protected void reduce(Text key, Iterable<Text> values, Context context) throws IOException, InterruptedException {

             AdjacentNodes adjacentNodes = new AdjacentNodes();

             Double sum = 0.0;
             for(Text adj : values)
             {
                 String str = adj.toString();
                 if(str.split("\t").length>1)
                 {
                     adjacentNodes.formatInfo(str);
                 }
                 else{
                     sum += Double.parseDouble(str);   //对节点的 pagerank 求和，
                 }
             }

             //计算pagerank
             double n = 0.80;
             double pagerank = sum * n + (1-n)/4.0;// 计算pagerank 公式 sum * n + (1-n)/N

             //计算收敛的差值
             int closure =(int)(Math.abs(pagerank - adjacentNodes.getValue()) * 1000);
             //通过context.getCounter(ENUM)方法，每次执行reduce将closure的值进行累加，结果传递给主函数，

             context.getCounter(ValueEnum.CLOSURE_VALUE).increment(closure);

             adjacentNodes.setValue(pagerank);
             context.write(key, new Text(adjacentNodes.toString()));
         }
     }
 }

AdjacentNodes.java

/**
 * Created by Edward on 2016/7/14.
 */
public class AdjacentNodes {

    double value = 0.0;
    int num = 0;
    String[] nodes = null;

    public void formatInfo(String str)
    {
        String[] val = str.split("\t");
        this.setValue(Double.parseDouble(val[0]));
        this.setNum(val.length-1);

        if(this.num != 0)
            this.nodes = new String[this.num];

        for(int i=1; i<val.length; i++)
        {
            this.nodes[i-1] = val[i];
        }
    }

    public boolean isEmpty()
    {
        if(this.num == 0)
            return true;
        else
            return false;
    }

    public void setNodes(String[] nodes) {
        this.nodes = nodes;
        this.num = nodes.length;
    }

    public void setNum(int num) {
        this.num = num;
    }

    public void setValue(double value) {
        this.value = value;
    }

    public double getValue() {
        return value;
    }

    public int getNum() {
        return num;
    }

    public String[] getNodes() {
        return nodes;
    }

    @Override
    public String toString() {

        StringBuffer stringBuffer = new StringBuffer(this.value+"");

        for(int i=0; i<this.num; i++)
        {
            stringBuffer.append("\t"+this.nodes[i]);
        }

        return stringBuffer.toString();
    }
}

结果数据：

A       0.10135294176208584     B       C       D
B       0.12838069628609527     A       D
C       0.6560527651143326      C
D       0.12838069628609527     B       C

总共执行了24次，之后收敛;

PageRank值越高，越值得推荐。