本地MapReduce的矩阵乘法

数据准备

为了方便说明，举两个矩阵作为示例：

，

容易看出，是一个矩阵，是一个矩阵，我们能够算出：

这三个矩阵当然不大，但作为示例，它们将暂时享受大矩阵的待遇。

比如矩阵在HDFS中存储为

1     1     1
1     2     2
1     3     3
2     1     4
2     2     5
3     1     7
3     2     8
3     3     9
4     1     10
4     2     11
4     3     12

矩阵存储为

1     1     10
1     2     15
2     2     2
3     1     11
3     2     9

注意到，，这样的值不会在文件中存储。

计算模型

注意，会被、……的计算所使用，会被、……的计算所使用。也就是说，在Map阶段，当我们从HDFS取出一行记录时，如果该记录是的元素，则需要存储成个<key, value>对，并且这个key互不相同；如果该记录是的元素，则需要存储成个<key, value>对，同样的，个key也应互不相同；但同时，用于计算的、存放、……和、……的<key, value>对的key应该都是相同的，这样才能被传递到同一个Reduce中。

经过以上分析，整个计算过程设计为：

（1）在Map阶段，把来自表的元素，标识成条<key, value>的形式。其中，；把来自表的元素，标识成条<key, value>形式，其中，。

于是乎，在Map阶段，我们实现了这样的战术目的：通过key，我们把参与计算的数据归为一类。通过value，我们能区分元素是来自还是，以及具体的位置。

（2）在Shuffle阶段，相同key的value会被加入到同一个列表中，形成<key, list(value)>对，传递给Reduce，这个由Hadoop自动完成。

（3）在Reduce阶段，有两个问题需要自己问问：

• 当前的<key, list(value)>对是为了计算的哪个元素？
• list中的每个value是来自表或表的哪个位置？

第一个问题可以从key中获知，因为我们在Map阶段已经将key构造为形式。第二个问题，也可以在value中直接读出，因为我们也在Map阶段做了标志。

接下来我们所要做的，就是把list(value)解析出来，来自的元素，单独放在一个数组中，来自的元素，放在另一个数组中，然后，我们计算两个数组（各自看成一个向量）的点积，即可算出的值。

示例矩阵和相乘的计算过程如下图所示：'

代码

package com.cx.mapreduce.ex;

import java.io.IOException;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;
import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.fs.Path;
import org.apache.hadoop.io.IntWritable;
import org.apache.hadoop.io.LongWritable;
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.Reducer.Context;
import org.apache.hadoop.mapreduce.lib.input.FileInputFormat;
import org.apache.hadoop.mapreduce.lib.output.FileOutputFormat;
import org.apache.hadoop.mapreduce.lib.input.FileSplit;

//author:chenxiao

public class MatrixMultiply {
    public static class MyMapper extends Mapper<LongWritable, Text, Text, Text> {
        private final int rowA = 4, columnA = 3;// 矩阵A的行数和列数
        private final int rowB = 3, columnB = 2;// 矩阵B的行数和列数，需满足columnA=rowB
        private final String SPILT = ",";

        @Override
        protected void map(LongWritable key, Text values, Context context)
                throws IOException, InterruptedException {
            String[] tokens = values.toString().split(SPILT);
            String flag1 = tokens[0];
            String flag2 = tokens[1];
            String value = tokens[2];

            // System.out.println(tokens.length);
            String pathname = ((FileSplit) context.getInputSplit()).getPath()
                    .toString();// 获取此时正在处理的文件的路径
            if (pathname.contains("matrix_A")) {
                for (int i = 1; i <= columnB; i++) {
                    context.write(new Text(flag1 + SPILT + i), new Text("A"
                            + SPILT + flag2 + SPILT + value));
                }
            }
            if (pathname.contains("matrix_B")) {
                for (int i = 1; i <= rowA; i++) {
                    context.write(new Text(i + SPILT + flag2), new Text("B"
                            + SPILT + flag1 + SPILT + value));
                }
            }

        }

    }

    public static class MyReducer extends
            Reducer<Text, IntWritable, Text, Text> {

        protected void reduce(Text key, Iterable<IntWritable> values,
                              Context context) throws IOException, InterruptedException {

            Map<String, Integer> mapA = new HashMap<String, Integer>();
            Map<String, Integer> mapB = new HashMap<String, Integer>();
            Iterator it = values.iterator();
            while (it.hasNext()) {
                String[] str = it.next().toString().split(",");
                if (str[0].equals("A")) {
                    mapA.put(str[1], Integer.parseInt(str[2]));
                } else {
                    mapB.put(str[1], Integer.parseInt(str[2]));
                }
            }
            int sum = 0;
            for (String k : mapA.keySet()) {
                if (mapB.containsKey(k)) {
                    sum += mapA.get(k) * mapB.get(k);
                }
            }
            context.write(key, new Text(String.valueOf(sum)));

        }
    }

    public static void main(String[] args) throws Exception {
        // TODO Auto-generated method stub
        Configuration conf = new Configuration();
//        conf.set("fs.default.name", "hdfs://localhost:9000");

        // 创建作业chenxiao
        Job job = new Job(conf, "MatrixMultiply");
        job.setJarByClass(MatrixMultiply.class);

        // 设置mr
        job.setMapperClass(MyMapper.class);
        job.setReducerClass(MyReducer.class);

        // 设置输出类型，和Context上下文对象write的参数类型一致
        job.setOutputKeyClass(Text.class);
        job.setOutputValueClass(Text.class);

        // 设置输入输出路径
        FileInputFormat.setInputPaths(job, new Path(
                "D:\\output"), new Path(
                "D:\\output"));
        FileOutputFormat.setOutputPath(job, new Path(
                "D:\\wcoutput"));

        // 执行
        System.exit(job.waitForCompletion(true) ? 0 : 1);
    }
}