MapReduce矩阵相乘

数据准备

$$A= \left[ \begin{matrix} 1 & 2 & 3 \\ 4 & 5 & 0 \\ 7 & 8 & 9 \end{matrix} \right] \tag{1}$$

$$B= \left[ \begin{matrix} 10 & 15 \\ 0 & 2 \\ 11 & 9 \end{matrix} \right] \tag{2}$$

容易看出，$A$是一个4 * 3矩阵，$B$是一个3 * 2矩阵，我们能够计算出：

$$C= AB = \left[ \begin{matrix} 43 & 46 \\ 40 & 70 \\ 169 & 202 \\ 232 & 280 \end{matrix} \right] \tag{3}$$

存储方式

理论上，在一个文件中存储4000万*4000万的矩阵当然是可以的，但非常失之优雅，因为这意味着在一条记录中挤下4000万个变量的值。

我们注意到，根据海量数据构造的矩阵，往往是极其稀疏的。比如4000万*4000万的相似度矩阵，一般来说，如果平均每个用户和1万个用户具有大于零的相似度，常识告诉我们，这样的关系网络已经非常密集了（实际网络不会这样密集，看看自己的微博，被你关注的、评论过的、转发过的对象，会达到1万个吗？）；但对于4000万维度的矩阵，它却依然是极度稀疏的。

因此，我们可以采用稀疏矩阵的存储方式，只存储那些非零的数值。具体而言，存储矩阵的文件每一条记录的结构如下：

$(i,j,A[i,j]）$

其中，第一个字段i 为行标签，第二个字段j ，第三个字段值为$A[i,j]$ 。

比如矩阵$A$ 在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

矩阵B在HDFS中存储为

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

注意到$A[2,3]=0$ ，$B[2,1]=0$ ，这样的值不会在文件中存储。

计算模型

回顾一下矩阵乘法。

设 $A=(a_{ij})_{mn}$ ，$B=(b_{jk})_{nl}$，那么
$C=AB=(c_{ik})_{ml}=(a_{i1}b_{1j}+\ldots+a_{in}b_{nj})_{ml}=(\sum_{k=1}^n a_{ik}b_{kj})_{ml}$

矩阵乘法要求左矩阵$A$ 的列数与右矩阵$B$ 的行数相等，$m * n$ 的矩阵$A$ ，与$n * l$的矩阵$B$ 相乘，结果为$m * l$ 的矩阵 $C$ 。

现在我们来分析一下，哪些操作是相互独立的（从而可以进行分布式计算）。很显然，$c_{11}$的计算和$c_{12}$的计算是互不干扰的；事实上，$C$ 中各个元素的计算都是相互独立的。这样，我们在Map阶段，可以把计算$c_{11}$所需要的元素都集中到同一个key中，然后，在Reduce阶段就可以从中解析出各个元素来计算$c_{11}$；$C$ 的其他元素的计算同理。

我们还需要注意，$a_{11}$会被$c_{11}、c_{12} \dots c_{1L}$的计算所使用，$b_{11}$会被$c_{11}、c_{21} \dots c_{m1}$的计算所使用。也就是说，在Map阶段，当我们从HDFS取出一行记录时，如果该记录是$A$ 的元素，则需要存储成L 个<key, value> 对，并且这L 个key互不相同；如果该记录是$B$ 的元素，则需要存储成m个< key, value> 对，同样的，m个key也应互不相同；但同时，用于计算$c_{11}$ 的、存放$a_{11}、a_{12} \dots a_{1L}$和$b_{11}、b_{21} \dots b_{m1}$的<key, value> 对的key应该都是相同的，这样才能被传递到同一个Reduce中。
经过以上分析，整个计算过程设计为：
（1）在Map阶段，把来自表$A$ 的元素$a_{ij}$，标识成L条<key, value>的形式。其中$key=(i，k)，k = 1,2，\dots ,l$ $value=('a'，j，a_{ij})$；把来自表$B$ 的元素标识成m 条 <key,value> 形式，其中
$key=(i，k)，k = 1,2，\dots ,m，value=('b'，j，b_{jk})$。
于是乎，在Map阶段，我们实现了这样的战术目的：通过key，我们把参与计算$c_{ik}$的数据归为一类。通过value，我们能区分元素是来自$A$ 还是$B$ ，以及具体的位置。
（2）在Shuffle阶段，相同key的value会被加入到同一个列表中，形成< key, list(value)>对，传递给Reduce，这个由Hadoop自动完成。
（3）在Reduce阶段，有两个问题需要自己问问：

• 当前的< key, list(value)>对是为了计算$C$ 的哪个元素？
• list中的每个value是来自表$A$ 或表$B$ 的哪个位置？
  第一个问题可以从key中获知，因为我们在Map阶段已经将key构造为$(i,k)$形式。第二个问题，也可以在value中直接读出，因为我们也在Map阶段做了标志。
  接下来我们所要做的，就是把list(value)解析出来，来自$A$ 的元素，单独放在一个数组中，来自$B$ 的元素，放在另一个数组中，然后，我们计算两个数组（各自看成一个向量）的点积，即可算出$c_{ik}$的值。
  示例矩阵$A$ 和$B$ 相乘的计算过程如下图所示：

代码

import java.io.IOException;
import java.util.HashMap;
import java.util.Iterator;
import java.util.StringTokenizer;

import org.apache.hadoop.fs.FileSystem;
import org.apache.hadoop.io.LongWritable;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.io.Writable;
import org.apache.hadoop.io.WritableComparable;
import org.apache.hadoop.mapred.FileSplit;
import org.apache.hadoop.mapred.JobConf;
import org.apache.hadoop.mapred.MapReduceBase;
import org.apache.hadoop.mapred.Mapper;
import org.apache.hadoop.mapred.OutputCollector;
import org.apache.hadoop.mapred.RecordWriter;
import org.apache.hadoop.mapred.Reducer;
import org.apache.hadoop.mapred.Reporter;
import org.apache.hadoop.mapred.TextOutputFormat;
import org.apache.hadoop.mapred.lib.MultipleOutputFormat;
import org.apache.hadoop.util.Progressable;

public class Bigmmult {
     public static final String CONTROL_I = "\u0009";
     public static final int MATRIX_I = 4;
     public static final int MATRIX_J = 3;
     public static final int MATRIX_K = 2;

     public static String makeKey(String[] tokens, String separator) {
          StringBuffer sb = new StringBuffer();
          boolean isFirst = true;
          for (String token : tokens) {
               if (isFirst)
                    isFirst = false;
               else
                    sb.append(separator);
               sb.append(token);
          }
          return sb.toString();
     }

     public static class MapClass extends MapReduceBase implements
               Mapper<LongWritable, Text, Text, Text> {         
          public static HashMap<String , Double> features = new HashMap<String, Double>();

          public void configure(JobConf job) {
               super.configure(job);
          }

          public void map(LongWritable key, Text value, OutputCollector<Text, Text> output,
                    Reporter reporter) throws IOException, ClassCastException {
               // 获取输入文件的全路径和名称
               String pathName = ((FileSplit)reporter.getInputSplit()).getPath().toString();

               if (pathName.contains("m_ys_lab_bigmmult_a")) {         
                    String line = value.toString();

                    if (line == null || line.equals("")) return;
                    String[] values = line.split(CONTROL_I);

                    if (values.length < 3) return;

                    String rowindex = values[0];
                    String colindex = values[1];
                    String elevalue = values[2];

                    for (int i = 1; i <= MATRIX_K; i ++) {
                         output.collect(new Text(rowindex + CONTROL_I + i), new Text("a#"+colindex+"#"+elevalue));
                    }
               }

               if (pathName.contains("m_ys_lab_bigmmult_b")) {              
                    String line = value.toString();
                    if (line == null || line.equals("")) return;
                    String[] values = line.split(CONTROL_I);

                    if (values.length < 3) return;

                    String rowindex = values[0];
                    String colindex = values[1];
                    String elevalue = values[2];

                    for (int i = 1; i <= MATRIX_I; i ++) {
                         output.collect(new Text(i + CONTROL_I + colindex), new Text("b#"+rowindex+"#"+elevalue));
                    }
               }
          }
     }

     public static class Reduce extends MapReduceBase
               implements Reducer<Text, Text, Text, Text> {
          public void reduce(Text key, Iterator<Text> values,
                    OutputCollector<Text, Text> output, Reporter reporter)
                    throws IOException {

               int[] valA = new int[MATRIX_J];
               int[] valB = new int[MATRIX_J];

               int i;
               for (i = 0; i < MATRIX_J; i ++) {
                    valA[i] = 0;
                    valB[i] = 0;
               }

               while (values.hasNext()) {
                    String value = values.next().toString();
                    if (value.startsWith("a#")) {
                         StringTokenizer token = new StringTokenizer(value, "#");
                         String[] temp = new String[3];
                         int k = 0;
                         while(token.hasMoreTokens()) {
                              temp[k] = token.nextToken();
                              k++;
                         }

                         valA[Integer.parseInt(temp[1])-1] = Integer.parseInt(temp[2]);
                    } else if (value.startsWith("b#")) {
                         StringTokenizer token = new StringTokenizer(value, "#");
                         String[] temp = new String[3];
                         int k = 0;
                         while(token.hasMoreTokens()) {
                              temp[k] = token.nextToken();
                              k++;
                         }

                         valB[Integer.parseInt(temp[1])-1] = Integer.parseInt(temp[2]);
                    }
               }

               int result = 0;
               for (i = 0; i < MATRIX_J; i ++) {
                    result += valA[i] * valB[i];
               }

               output.collect(key, new Text(Integer.toString(result)));
          }
     }
}