MapReduce实现PageRank算法（邻接矩阵法）

前言

之前写过稀疏图的实现方法，这次写用矩阵存储数据的算法实现，只要会矩阵相乘的话，实现这个就很简单了。如果有不懂的可以先看一下下面两篇随笔。

MapReduce实现PageRank算法（稀疏图法）

Python+MapReduce实现矩阵相乘

 

算法实现

我们需要输入两个矩阵A和B，我一开始想的是两个矩阵分别存在两个文件里然后分别读取，但是我发现好像不行，无法区分打上A、B的标签。

所以我一开始就把A、B矩阵合起来存在一个文件里，一次读取。 

map.py

#!/usr/bin/env python3
import os
import sys

flag = 0       # 0表示处理A矩阵，1表示处理B矩阵
current_row = 1  # 记录现在处理矩阵的第几行


def read_input():
    for lines in sys.stdin:
        yield lines


if __name__ == '__main__':
    row_a = int(os.environ.get('row_a'))
    col_a = int(os.environ.get('col_a'))
    row_b = int(os.environ.get('row_b'))
    col_b = int(os.environ.get('col_b'))
    for line in read_input():
        if line.count('
') == len(line):    # 去空行
            pass
        data = line.strip().split('	')

        if flag == 0:
            for i in range(col_b):
                for j in range(col_a):
                    print("%s,%s	A:%s,%s" % (current_row, i+1, j+1, data[j]))
            current_row += 1
            if current_row > row_a:
                flag = 1
                current_row = 1

        elif flag == 1:
            for i in range(row_a):
                for j in range(col_b):
                    print("%s,%s	B:%s,%s" % (i+1, j+1, current_row, data[j]))
            current_row += 1

reduce.py

#!/usr/bin/env python3
import os
import sys
from itertools import groupby
from operator import itemgetter


def read_input(splitstr):
    for line in sys.stdin:
        line = line.strip()
        if len(line) == 0:
            continue
        yield line.split(splitstr)


if __name__ == '__main__':
    alpha = float(os.environ.get('alpha'))
    row_b = int(os.environ.get('row_b'))

    data = read_input('	')
    lstg = (groupby(data, itemgetter(0)))
    try:
        for flag, group in lstg:
            matrix_a, matrix_b = {}, {}
            total = 0.0
            for element, g in group:
                matrix = g.split(':')[0]
                pos = g.split(':')[1].split(',')[0]
                value = g.split(',')[1]
                if matrix == 'A':
                    matrix_a[pos] = value
                else:
                    matrix_b[pos] = value
            for key in matrix_a:
                total += float(matrix_a[key]) * float(matrix_b[key])
            page_rank = alpha * total + (1.0 - alpha) / row_b
            print("%s" % page_rank)
    except Exception:
        pass

算法运行

由于每次迭代会产生新的值，又因为我无法分两个文件读取，所以每次迭代后我要将网络矩阵和新的pageRank值合起来再上传至HDFS。

下面的Python代码的功能就是合并和记录迭代值。

#!/usr/bin/env python3
import sys


number = sys.stdin.readline().strip()

f_src = open("tmp.txt","r")
f_dst1 = open("result.txt", "a")
f_dst2 = open("B.txt", "a")


mat = "{:^30}	"
f_dst1.write('
' + number)

lines = f_src.readlines()
for line in lines:
    if line.count('
') == len(line):
        continue
    line = line.strip()
    f_dst1.write(mat.format(line))
    f_dst2.write(line)
    f_dst2.write('
')

 再贴一下运行脚本run.sh

#!/bin/bash

pos="/usr/local/hadoop"
max=10

for i in `seq 1 $max`
do

    $pos/bin/hadoop jar $pos/hadoop-streaming-2.9.2.jar 
    -mapper $pos/mapper.py 
    -file $pos/mapper.py 
    -reducer $pos/reducer.py 
    -file $pos/reducer.py 
    -input B.txt 
    -output out 
    -cmdenv "row_a=4" 
    -cmdenv "col_a=4" 
    -cmdenv "row_b=4" 
    -cmdenv "col_b=1" 
    -cmdenv "alpha=0.8" 

    
    rm -r ~/Desktop/B.txt
    cp ~/Desktop/A.txt ~/Desktop/B.txt
    rm -r ~/Desktop/tmp.txt
    $pos/bin/hadoop fs -get out/part-00000 ~/Desktop/tmp.txt
    echo $i | ~/Desktop/slove.py

    $pos/bin/hadoop fs -rm B.txt
    $pos/bin/hadoop fs -rm -r -f out
    $pos/bin/hadoop fs -put ~/Desktop/B.txt B.txt
done

 我这里就随便迭代了10次：

我感觉mapreduce用来处理迭代计算实在是太麻烦了，所以才会有twister、haloop、spark这些开源框架的出现吧。