MapReduce实现大矩阵乘法

最新推荐文章于 2020-03-23 20:57:18 发布
最新推荐文章于 2020-03-23 20:57:18 发布
阅读量611 收藏
点赞数
分类专栏： 数据挖掘 文章标签： mapreduce matrix


引言

何为大矩阵？Excel、SPSS，甚至SAS处理不了或者处理起来非常困难，需要设计巧妙的分布式方法才能高效解决基本运算（如转置、加法、乘法、求逆）的矩阵，我们认为其可被称为大矩阵。这意味着此种矩阵的维度至少是百万级的、经常是千万级的、有时是亿万级的。举个形象的栗子。至2012年12月底，新浪微博注册用户数超5亿，日活跃用户4629万[1]，如果我们要探索这4000多万用户可以分成哪些类别，以便深入了解用户共同特征，制定精准营销策略，势必要用到聚类相关的算法（比如新浪大牛张俊林就利用聚类算法来挖掘新浪微博中的兴趣圈子[2]），而聚类算法都需要构造用户两两之间的关系，形成n*n的矩阵，称为相似度矩阵。新浪微博这个例子中，这个矩阵的维度是4000万*4000万。

大矩阵乘法为何重要？这个时代（我就不说那个被媒体用烂了的恶心词汇了），在海量数据中淘金，已是各大互联网公司的既定目标，亚马逊是数据化运营的成功典范，Google、百度投巨资用于对海量数据进行深度学习（Deep Learning）研究，阿里把数据与平台、金融并列成为未来三大战略。话扯得有点大而远，但任何伟大的战略，最终都要落地到非常细粒度的具体操作上。我们想在海量数据中淘到金子，强大的挖掘工具是必不可少的，而诸如回归、聚类、主成分分析、决策树等数据挖掘算法常常涉及大规模矩阵运算。这其中，大矩阵乘法具有较大的时间消耗，是算法的瓶颈。张俊林的文章[2]用到了谱聚类算法，其中有个重要步骤是将相似度矩阵转换为拉普拉斯矩阵，这就需要用到大矩阵乘法。很酷有没有！大矩阵乘法运算可以从根基上影响数据战略的实施，它比那些大而空的废话重要千百万倍。

我们将使用MapReduce来分布式计算大矩阵乘法。伟大导师黑格尔告诉我们，量变导致质变。当所操作的矩阵维度达到百万、千万级时，会产生亟待攻克的新问题：
  • 大矩阵如何存储？
  • 计算模型如何设计？
  • 矩阵维度如何传递给乘法运算？
第3个问题看似与矩阵的“大”无关，但实际上，当矩阵规模巨大时，我们就不太可能像对待小规模矩阵一样将整个矩阵读入内存、从而在一个job中就判断出其维度，而是需要分开成为两个job，第一个job专注于计算矩阵维度并存入全局变量，传递给第二个job做乘法运算。MapReduce中全局变量的传递，可以专门写一篇长文来讨论，本文中我们假定矩阵维度已知，并在代码中写死，从而先着眼于解决前两个问题。

数据准备

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

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

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

存储方式

理论上，在一个文件中存储4000万*4000万的矩阵当然是可以的，但非常失之优雅，因为这意味着在一条记录中挤下4000万个变量的值。
我们注意到，根据海量数据构造的矩阵，往往是极其稀疏的。比如4000万*4000万的相似度矩阵，一般来说，如果平均每个用户和1万个用户具有大于零的相似度，常识告诉我们，这样的关系网络已经非常密集了（实际网络不会这样密集，看看自己的微博，被你关注的、评论过的、转发过的对象，会达到1万个吗？）；但对于4000万维度的矩阵，它却依然是极度稀疏的。
因此，我们可以采用稀疏矩阵的存储方式，只存储那些非零的数值。具体而言，存储矩阵的文件每一条记录的结构如下：

其中，第一个字段为行标签，第二个字段为列标签，第三个字段值为。
比如矩阵在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阶段，可以把计算所需要的元素都集中到同一个key中，然后，在Reduce阶段就可以从中解析出各个元素来计算；的其他元素的计算同理。

我们还需要注意，会被、……的计算所使用，会被、……的计算所使用。也就是说，在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)解析出来，来自的元素，单独放在一个数组中，来自的元素，放在另一个数组中，然后，我们计算两个数组（各自看成一个向量）的点积，即可算出的值。
示例矩阵和相乘的计算过程如下图所示：

代码

主要代码如下：
[java]  view plain copy print ? 在CODE上查看代码片 派生到我的代码片
  1. import java.io.IOException;  
  2. import java.util.HashMap;  
  3. import java.util.Iterator;  
  4. import java.util.StringTokenizer;  
  5.   
  6. import org.apache.hadoop.fs.FileSystem;  
  7. import org.apache.hadoop.io.LongWritable;  
  8. import org.apache.hadoop.io.Text;  
  9. import org.apache.hadoop.io.Writable;  
  10. import org.apache.hadoop.io.WritableComparable;  
  11. import org.apache.hadoop.mapred.FileSplit;  
  12. import org.apache.hadoop.mapred.JobConf;  
  13. import org.apache.hadoop.mapred.MapReduceBase;  
  14. import org.apache.hadoop.mapred.Mapper;  
  15. import org.apache.hadoop.mapred.OutputCollector;  
  16. import org.apache.hadoop.mapred.RecordWriter;  
  17. import org.apache.hadoop.mapred.Reducer;  
  18. import org.apache.hadoop.mapred.Reporter;  
  19. import org.apache.hadoop.mapred.TextOutputFormat;  
  20. import org.apache.hadoop.mapred.lib.MultipleOutputFormat;  
  21. import org.apache.hadoop.util.Progressable;  
  22.   
  23. public class Bigmmult {  
  24.      public static final String CONTROL_I = "\u0009";  
  25.      public static final int MATRIX_I = 4;  
  26.      public static final int MATRIX_J = 3;  
  27.      public static final int MATRIX_K = 2;  
  28.       
  29.      public static String makeKey(String[] tokens, String separator) {  
  30.           StringBuffer sb = new StringBuffer();  
  31.           boolean isFirst = true;  
  32.           for (String token : tokens) {  
  33.                if (isFirst)  
  34.                     isFirst = false;  
  35.                else  
  36.                     sb.append(separator);  
  37.                sb.append(token);  
  38.           }  
  39.           return sb.toString();  
  40.      }  
  41.       
  42.      public static class MapClass extends MapReduceBase implements  
  43.                Mapper<LongWritable, Text, Text, Text> {           
  44.           public static HashMap<String , Double> features = new HashMap<String, Double>();  
  45.            
  46.           public void configure(JobConf job) {  
  47.                super.configure(job);  
  48.           }  
  49.            
  50.           public void map(LongWritable key, Text value, OutputCollector<Text, Text> output,  
  51.                     Reporter reporter) throws IOException, ClassCastException {  
  52.                // 获取输入文件的全路径和名称  
  53.                String pathName = ((FileSplit)reporter.getInputSplit()).getPath().toString();  
  54.                 
  55.                if (pathName.contains("m_ys_lab_bigmmult_a")) {           
  56.                     String line = value.toString();  
  57.                      
  58.                     if (line == null || line.equals("")) return;  
  59.                     String[] values = line.split(CONTROL_I);  
  60.                      
  61.                     if (values.length < 3) return;  
  62.                      
  63.                     String rowindex = values[0];  
  64.                     String colindex = values[1];  
  65.                     String elevalue = values[2];  
  66.                      
  67.                     for (int i = 1; i <= MATRIX_K; i ++) {  
  68.                          output.collect(new Text(rowindex + CONTROL_I + i), new Text("a#"+colindex+"#"+elevalue));  
  69.                     }  
  70.                }  
  71.                 
  72.                if (pathName.contains("m_ys_lab_bigmmult_b")) {                
  73.                     String line = value.toString();  
  74.                     if (line == null || line.equals("")) return;  
  75.                     String[] values = line.split(CONTROL_I);  
  76.                      
  77.                     if (values.length < 3) return;  
  78.                      
  79.                     String rowindex = values[0];  
  80.                     String colindex = values[1];  
  81.                     String elevalue = values[2];  
  82.                      
  83.                     for (int i = 1; i <= MATRIX_I; i ++) {  
  84.                          output.collect(new Text(i + CONTROL_I + colindex), new Text("b#"+rowindex+"#"+elevalue));  
  85.                     }  
  86.                }  
  87.           }  
  88.      }  
  89.   
  90.      public static class Reduce extends MapReduceBase  
  91.                implements Reducer<Text, Text, Text, Text> {  
  92.           public void reduce(Text key, Iterator<Text> values,  
  93.                     OutputCollector<Text, Text> output, Reporter reporter)  
  94.                     throws IOException {  
  95.                 
  96.                int[] valA = new int[MATRIX_J];  
  97.                int[] valB = new int[MATRIX_J];  
  98.                 
  99.                int i;  
  100.                for (i = 0; i < MATRIX_J; i ++) {  
  101.                     valA[i] = 0;  
  102.                     valB[i] = 0;  
  103.                }  
  104.                 
  105.                while (values.hasNext()) {  
  106.                     String value = values.next().toString();  
  107.                     if (value.startsWith("a#")) {  
  108.                          StringTokenizer token = new StringTokenizer(value, "#");  
  109.                          String[] temp = new String[3];  
  110.                          int k = 0;  
  111.                          while(token.hasMoreTokens()) {  
  112.                               temp[k] = token.nextToken();  
  113.                               k++;  
  114.                          }  
  115.                           
  116.                          valA[Integer.parseInt(temp[1])-1] = Integer.parseInt(temp[2]);  
  117.                     } else if (value.startsWith("b#")) {  
  118.                          StringTokenizer token = new StringTokenizer(value, "#");  
  119.                          String[] temp = new String[3];  
  120.                          int k = 0;  
  121.                          while(token.hasMoreTokens()) {  
  122.                               temp[k] = token.nextToken();  
  123.                               k++;  
  124.                          }  
  125.                           
  126.                          valB[Integer.parseInt(temp[1])-1] = Integer.parseInt(temp[2]);  
  127.                     }  
  128.                }  
  129.                 
  130.                int result = 0;  
  131.                for (i = 0; i < MATRIX_J; i ++) {  
  132.                     result += valA[i] * valB[i];  
  133.                }  
  134.                 
  135.                output.collect(key, new Text(Integer.toString(result)));  
  136.           }  
  137.      }  
  138. }  

转自http://blog.csdn.net/xyilu/article/details/9066973


参考资料

wen008215
关注
专栏目录
用MapReduce实现矩阵乘法
fens的博客
01-15 1110
Hadoop家族系列文章，主要介绍Hadoop家族产品，常用的项目包括Hadoop, Hive, Pig, HBase, Sqoop, Mahout, Zookeeper, Avro, Ambari, Chukwa，新增加的项目包括，YARN, Hcatalog, Oozie, Cassandra, Hama, Whirr, Flume, ...
MapReduce实现矩阵乘法的一些总结
huangbx_tx的博客
11-06 2984
MapReduce实现矩阵乘法的一些总结 文章目录MapReduce实现矩阵乘法的一些总结矩阵乘法概述MapReduce 思路具体方法 1具体方法 2具体方法 3实现代码结果分析一些杂杂碎碎Hex 与 bytes 与 Int 的转换Hadoop 环境配置本地调试本地安装 hadoop如何修改 mapper，reducer 数量参考资料 矩阵乘法概述 对于矩阵乘法 A(i,j)∗B(j,k)=C(i,k)A(i,j) * B(j,k) = C(i,k)A(i,j)∗B(j,k)=C(i,k)，有： (i,k
MapReduce实现矩阵乘法
热门推荐
沉潜飞动
10-10 2万+
在海量数据中淘金，已是各大互联网公司的既定目标，亚马逊是数据化运营的成功典范，Google、百度投巨资用于对海量数据进行深度学习研究，阿里把数据与平台、金融并列成为未来三大战略。想在海量数据中淘到金子，强大的挖掘工具是必不可少的，而诸如回归、聚类、主成分分析、决策树等数据挖掘算法常常涉及大规模矩阵运算。这其中，大矩阵乘法具有较大的时间消耗，是算法的瓶颈。所以将矩阵乘法移植到分布式系统中进行运算，可谓是基本需求，所以本文暂且从最基础开始，简单介绍使用MapReduce实现矩阵乘法的方式。
MapReduce 矩阵乘法
weixin_30549175的博客
11-30 381
一、对朴素简单直接方法 把m*n 和n*l的矩阵A和B相乘，这估计是最容易想到的方法了： 把A（m*n）的元素，每个发送l次，把B（n*l）的元素每个发送m次。将发送到一起的数据相乘求和，得到最后的结果。 优点：在知道坐标的情况下，这个过程就一轮mapreduce。 缺点：每个值要被发送多次。m*n 和n*l的矩阵，发送的元素有m*l*2次，比如100万的方...
Mapreduce实现矩阵乘法
BehandTheTime的博客
02-22 606
package myHadoop.Hadoop_Matrix; import java.io.IOException; import org.apache.hadoop.conf.Configuration; import org.apache.hadoop.fs.Path; import org.apache.hadoop.io.Text; import org.apache.hadoop.m
java 矩阵乘法的mapreduce程序实现
08-30
java 矩阵乘法的mapreduce程序实现使用了Hadoop的MapReduce框架来实现矩阵乘法的操作，这使得程序可以并行化处理大规模数据，从而提高计算效率。该程序可以广泛应用于机器学习、数据挖掘、科学计算等领域。
mapreduce实现矩阵相乘
weixin_33672400的博客
08-19 468
2019独角兽企业重金招聘Python工程师标准>>> ...
大数据MapReduce实例：实现矩阵乘法
x1Nge的博客
03-23 3370
MapReduce实现矩阵乘法 @author：x1nge 大数据基础实验 目录MapReduce实现矩阵乘法具体分析问题源码 具体分析 1.考虑怎么利用map和reduce来计算矩阵乘法，想到这里的时候我脑子里有成千上万个解法，像map的key和value要怎么输出啊之类的，一时间我不知道哪一种计算方法比较高效，但是经过半节课的深思熟虑以后，我把总体的思路定为：map的key输出空值，va...
MapReduce实现矩阵相乘算法
11-29
使用Hadoop MapReduce实现两个矩阵相乘算法
矩阵乘法的MapReduce实现
weixin_30423977的博客
01-07 285
对于任意矩阵M和N，若矩阵M的列数等于矩阵N的行数，则记M和N的乘积为P=M*N，其中mik 记做矩阵M的第i行和第k列，nkj记做矩阵N的第k行和第j列，则矩阵P中，第i行第j列的元素可表示为公式（1-1）： pij=(M*N)ij=∑miknkj=mi1*n1j+mi2*n2j+……+mik*nkj　　　　　　（公式1-1） 由公式（1-1）可以看出，最后决定pij是(i,j)，所以可以...
MapReduce实现矩阵相乘
小江专栏
03-31 8587
前言 MapReduce打开了并行计算的大门，让我们个人开发者有了处理大数据的能力。但想用好MapReduce，把原来单机算法并行化，也不是一件容易事情。很多的时候，我们需要从单机算法能否矩阵化去思考，所以矩阵操作就变成了算法并行化的基础。 矩阵介绍 为了方便说明，举两个矩阵作为示例： ， 容易看出，是一个矩阵，是一个矩阵，我们能够算出： 这三个矩阵当然不大，但
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值