数据准备
为了方便说明,举两个矩阵作为示例:
,
容易看出,是一个矩阵,是一个矩阵,我们能够算出:
这三个矩阵当然不大,但作为示例,它们将暂时享受大矩阵的待遇。
比如矩阵在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);
}
}