用MapReduce进行数据密集型文本处理-本地聚合（下）

最新推荐文章于 2020-06-04 20:35:52 发布
最新推荐文章于 2020-06-04 20:35:52 发布
阅读量122 收藏
点赞数
文章标签： 大数据 python
原文链接：https://my.oschina.net/juliashine/blog/106165
版权

2019独角兽企业重金招聘Python工程师标准>>> hot3.png

本文另一地址请见用MapReduce进行数据密集型文本处理-本地聚合（下）

本文译自 Working Through Data-Intensive Text Processing with MapReduce – Local Aggregation Part II

本文是《Data Intensive Processing with MapReduce》中的算法实现系列文章的最新一篇。该系列文章的第一篇在此 。在第一篇里，我们讨论了使用本地聚合技术来减少shuffle阶段的网络传输数据量。减少需要传输的数据量是提高mapreduce job的性能的最有效的办法。我们在上一篇文章里用了word count来演示本地聚合。因为我们需要的只是一个最终统计结果，而在计算最终结果的过程中改变累加的分组与顺序都不会影响最终结果，所以我们可以重用reducer来作为combiner。但是如果想计算平均值怎么办？这种情况下原来的办法就行不通了，因为总体的平均值不等于各部分平均值的平均。不过如果能够清楚的意识到这一点，我们还是可以使用本地聚合方法的。在本文的例子中我们将使用 在《Hadoop经典指南》中出现过的 美国国家气候中心的天气数据  样本来计算1901年每个月的平均气温。使用combiner和mapper中聚合的计算平均值的算法可在《Data Intensive Processing with MapReduce》的3.1.3找到。

没有放之四海而皆准的方法

我们在上一篇文章里介绍了两种减少数据的方法，Hadoop Combiner和在mapper中聚合。Combiner被视为是一个优化措施，因此框架不会保证它会被调用多少次。所以，mapper输出的数据格式必须是符合reducer输入格式的，以便在combiner根本没有运行的情况下最终结果还是正确的。为了计算平均气温，我们需要改变一下mapper的输出。

Mapper 的变化

在 word-count的例子里，没有优化的mapper输出每个词和值为1的计数。combiner和在mapper中聚合的方法通过一个hashmap，将每个词作为key，出现次数作为值，保存在hashmap中来减少输出。如果combiner没有调用，reducer将收到一系列key是单词，值为1的数据，这与之前的结果是一样的。（如果使用在mapper中聚合的话就不会发生这种情况，因为聚合是发生在mapper的代码里的，所以一定会被执行）。为了计算平均值，我们的mapper需要输出一个字符串key（年月）和一个定制的实现了writable接口的对象， TemperatureAveragingPair。这个对象有两个数字属性，气温以及该气温的频数。我们可以参考《Hadoop经典指南》中的 MaximumTemperatureMapper  来建立 AverageTemperatureMapper：
01 public class AverageTemperatureMapper extendsMapper<LongWritable, Text, Text, TemperatureAveragingPair> {
02  //sample line of weather data
03  //0029029070999991901010106004+64333+023450FM-12+000599999V0202701N015919999999N0000001N9-00781+99999102001ADDGF10899199999999999
04  
05  
06     private Text outText = new Text();
07     private TemperatureAveragingPair pair = new TemperatureAveragingPair();
08     private static final int MISSING = 9999;
09  
10     @Override
11     protected void map(LongWritable key, Text value, Context context) throwsIOException, InterruptedException {
12         String line = value.toString();
13         String yearMonth = line.substring(15, 21);
14  
15         int tempStartPosition = 87;
16  
17         if (line.charAt(tempStartPosition) == '+') {
18             tempStartPosition += 1;
19         }
20  
21         int temp = Integer.parseInt(line.substring(tempStartPosition, 92));
22  
23         if (temp != MISSING) {
24             outText.set(yearMonth);
25             pair.set(temp, 1);
26             context.write(outText, pair);
27         }
28     }
29 }

通过让mapper输出key和TemperatureAveragingPair对象，不管combiner有没有执行我们的mapreduce程序都能输出正确的结果。

Combiner

我们要减少传输的数据量，就要尽可能把相同气温的计数合并，但是又不能影响最终的平均数计算。当combiner执行的时候，它会把具有相同key的TemperatureAveragingPair 合并成一个，包含汇总的气温和频度计数。下面是combiner的代码：

01   public class AverageTemperatureCombiner extendsReducer<Text,TemperatureAveragingPair,Text,TemperatureAveragingPair> {
02     private TemperatureAveragingPair pair = new TemperatureAveragingPair();
03  
04     @Override
05     protected voidreduce(Text key, Iterable<TemperatureAveragingPair> values, Context context) throwsIOException, InterruptedException {
06         int temp = 0;
07         int count = 0;
08         for (TemperatureAveragingPair value : values) {
09              temp += value.getTemp().get();
10              count += value.getCount().get();
11         }
12         pair.set(temp,count);
13         context.write(key,pair);
14     }
15 }

但是我们确实很关心如何减少需要传输给reducer的数据量，下面我们将会看看如何实现这个目的。

在mapper中合并平均值

与word-count相同，为了计算均值，在mapper中合并的方法会用到一个hashmap，它以年月为key，以TemperatureAveragingPair为值。合并相同年月的数据的时候我们需要取出以该年月为key的TemperatureAveragingPair对象，将temperature属性和count属性累加。最后在cleanUp方法被调用的时候会输出hashmap中所有的key和TemperatureAveragingPair。

01 public class AverageTemperatureCombiningMapper extendsMapper<LongWritable, Text, Text, TemperatureAveragingPair> {
02  //sample line of weather data
03  //0029029070999991901010106004+64333+023450FM-12+000599999V0202701N015919999999N0000001N9-00781+99999102001ADDGF10899199999999999
04  
05  
06     private static final int MISSING = 9999;
07     private Map<String,TemperatureAveragingPair> pairMap = newHashMap<String,TemperatureAveragingPair>();
08  
09  
10     @Override
11     protected void map(LongWritable key, Text value, Context context) throwsIOException, InterruptedException {
12         String line = value.toString();
13         String yearMonth = line.substring(15, 21);
14  
15         int tempStartPosition = 87;
16  
17         if (line.charAt(tempStartPosition) == '+') {
18             tempStartPosition += 1;
19         }
20  
21         int temp = Integer.parseInt(line.substring(tempStartPosition, 92));
22  
23         if (temp != MISSING) {
24             TemperatureAveragingPair pair = pairMap.get(yearMonth);
25             if(pair == null){
26                 pair = new TemperatureAveragingPair();
27                 pairMap.put(yearMonth,pair);
28             }
29             int temps = pair.getTemp().get() + temp;
30             int count = pair.getCount().get() + 1;
31             pair.set(temps,count);
32         }
33     }
34  
35  
36     @Override
37     protected void cleanup(Context context) throws IOException, InterruptedException {
38         Set<String> keys = pairMap.keySet();
39         Text keyText = new Text();
40         for (String key : keys) {
41              keyText.set(key);
42              context.write(keyText,pairMap.get(key));
43         }
44     }
45 }

用这种在mapper中合并的方法，我们在多次map调用之间保存了信息，确保了能够对产出数据进行削减。尽管保持跨mapper的状态是一件需要小心的事情，但这在某些情况下确实很有效。

Reducer

在这种情况reducer的逻辑就很简单了，遍历每个key的所有值，把temperatures 和counts加和，然后相除。

01 public class AverageTemperatureReducer extendsReducer<Text, TemperatureAveragingPair, Text, IntWritable> {
02     private IntWritable average = new IntWritable();
03  
04     @Override
05     protected voidreduce(Text key, Iterable<TemperatureAveragingPair> values, Context context) throwsIOException, InterruptedException {
06         int temp = 0;
07         int count = 0;
08         for (TemperatureAveragingPair pair : values) {
09             temp += pair.getTemp().get();
10             count += pair.getCount().get();
11         }
12         average.set(temp / count);
13         context.write(key, average);
14     }
15 }

结果

正如预料，使用了combiner和mapper中合并方法的结果大幅减少了输出数据。
没有优化的情况:

01 12/10/10 23:05:28 INFO mapred.JobClient:     Reduce input groups=12
02 12/10/10 23:05:28 INFO mapred.JobClient:     Combine output records=0
03 12/10/10 23:05:28 INFO mapred.JobClient:     Map input records=6565
04 12/10/10 23:05:28 INFO mapred.JobClient:     Reduce shuffle bytes=111594
05 12/10/10 23:05:28 INFO mapred.JobClient:     Reduce output records=12
06 12/10/10 23:05:28 INFO mapred.JobClient:     Spilled Records=13128
07 12/10/10 23:05:28 INFO mapred.JobClient:     Map output bytes=98460
08 12/10/10 23:05:28 INFO mapred.JobClient:     Total committed heap usage (bytes)=269619200
09 12/10/10 23:05:28 INFO mapred.JobClient:     Combine input records=0
10 12/10/10 23:05:28 INFO mapred.JobClient:     Map output records=6564
11 12/10/10 23:05:28 INFO mapred.JobClient:     SPLIT_RAW_BYTES=108
12 12/10/10 23:05:28 INFO mapred.JobClient:     Reduce input records=6564

使用了Combiner的情况:

01 12/10/10 23:07:19 INFO mapred.JobClient:     Reduce input groups=12
02 12/10/10 23:07:19 INFO mapred.JobClient:     Combine output records=12
03 12/10/10 23:07:19 INFO mapred.JobClient:     Map input records=6565
04 12/10/10 23:07:19 INFO mapred.JobClient:     Reduce shuffle bytes=210
05 12/10/10 23:07:19 INFO mapred.JobClient:     Reduce output records=12
06 12/10/10 23:07:19 INFO mapred.JobClient:     Spilled Records=24
07 12/10/10 23:07:19 INFO mapred.JobClient:     Map output bytes=98460
08 12/10/10 23:07:19 INFO mapred.JobClient:     Total committed heap usage (bytes)=269619200
09 12/10/10 23:07:19 INFO mapred.JobClient:     Combine input records=6564
10 12/10/10 23:07:19 INFO mapred.JobClient:     Map output records=6564
11 12/10/10 23:07:19 INFO mapred.JobClient:     SPLIT_RAW_BYTES=108
12 12/10/10 23:07:19 INFO mapred.JobClient:     Reduce input records=12

在mapper中合并的情况:

01 12/10/10 23:09:09 INFO mapred.JobClient:     Reduce input groups=12
02 12/10/10 23:09:09 INFO mapred.JobClient:     Combine output records=0
03 12/10/10 23:09:09 INFO mapred.JobClient:     Map input records=6565
04 12/10/10 23:09:09 INFO mapred.JobClient:     Reduce shuffle bytes=210
05 12/10/10 23:09:09 INFO mapred.JobClient:     Reduce output records=12
06 12/10/10 23:09:09 INFO mapred.JobClient:     Spilled Records=24
07 12/10/10 23:09:09 INFO mapred.JobClient:     Map output bytes=180
08 12/10/10 23:09:09 INFO mapred.JobClient:     Total committed heap usage (bytes)=269619200
09 12/10/10 23:09:09 INFO mapred.JobClient:     Combine input records=0
10 12/10/10 23:09:09 INFO mapred.JobClient:     Map output records=12
11 12/10/10 23:09:09 INFO mapred.JobClient:     SPLIT_RAW_BYTES=108
12 12/10/10 23:09:09 INFO mapred.JobClient:     Reduce input records=12

计算结果：
(注意: 例子里使用的文件中的的温度是摄氏度*10的结果)

Non-Optimized Combiner       In-Mapper-Combiner Mapper
190101 -25
190102 -91
190103 -49
190104 22
190105 76
190106 146
190107 192
190108 170
190109 114
190110 86
190111 -16
190112 -77 		190101 -25
190102 -91
190103 -49
190104 22
190105 76
190106 146
190107 192
190108 170
190109 114
190110 86
190111 -16
190112 -77 		190101 -25
190102 -91
190103 -49
190104 22
190105 76
190106 146
190107 192
190108 170
190109 114
190110 86
190111 -16
190112 -77
结论

我们用两种场景来演示了本地聚合，一个场景比较简单只要简单重用reducer作为combiner就可以，另一个稍微复杂一些，必须对数据做一定的组织，这两种例子都充分证明了本地聚合能够极大提高处理过程的效率。

相关资源



转载于:https://my.oschina.net/juliashine/blog/106165

weixin_33701251
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
MapReduce聚合
fansy1990的专栏
09-07 3046
mapreduce的核心思想就是：map读入一条记录，然后重置其key 、value；reduce针对map的同一条key，把其values整合，然后重新输出key、value; 这两天做mapreduce时，忽然有种想法：针对一行记录,是否有输出多行记录，包含有不同到key，value，的情况；这种情况到应用是否有好处呢？ 假设有这样的一个数据：其中第一列代表用户的标识，第二列代表书籍的
《数据密集型计算和模型》第四章_MapReduce模型
sandy_star
12-28 996
《数据密集型计算和模型》第四章的有关内容。主要有MapReduce模型简介、概念及原理、工作机制、优缺点；基于MapReduce模型的实现，改进等。 文章目录一、MapReduce模型简介1. MapReduce模型概念及原理2. MapReduce工作机制（1）MapReduce作业的工作机制主节点（master）数据分片（Data split）Map端Shuffle&SortReduce端（2）容错机制工作节点容错主节点容错任务语义容错（3）负载平衡作业调度任务本地调度任务备份计数器3. M.
MapReduce高级编程之本地聚集与Combinner
04-02
NULL 博文链接：https://irwenqiang.iteye.com/blog/1453740
用MapReduce进行数据密集型文本处理 – 本地聚合（下）
小小八卦姐的专栏
10-05 958
本文译自 Working Through Data-Intensive Text Processing with MapReduce – Local Aggregation Part II 本文是《Data Intensive Processing with MapReduce》中的算法实现系列文章的最新一篇。在第一篇里，我们讨论了使用本地聚合技术来减少shuffle阶段的网络传输数据量
用MapReduce进行数据密集型文本处理-本地聚合（上）
weixin_34320159的博客
01-28 117
2019独角兽企业重金招聘Python工程师标准>>> ...
用MapReduce进行数据密集型文本处理-本地聚合
weixin_34124651的博客
05-06 134
2019独角兽企业重金招聘Python工程师标准>>> ...
使用MapReduce进行数据密集型文本处理Data-Intensive Text Processing with MapReduce
11-15
本书重点介绍MapReduce算法设计，重点介绍自然语言处理，信息检索和机器学习中常见的文本处理算法。
《MapReduce数据密集型文本处理》.pdf
04-21
标题所指的《MapReduce数据密集型文本处理》是关于MapReduce算法在处理大规模数据集中的应用，尤其专注于文本数据。此书由Jimmy Lin和Chris Dyer撰写，是Morgan & Claypool Synthesis Lectures on Human Language ...
用mapreduce进行文本处理
09-09
##### 3.1 数据密集型文本处理 在文本处理领域，MapReduce 被广泛应用于诸如文档检索、信息提取、语义分析等场景。例如，可以利用 MapReduce 对大规模网页数据进行索引和分析。 - **文档检索**：通过 MapReduce ...
mapreduce-examples:mapreduce-examples
06-27
《MapReduce 示例详解》 MapReduce 是一种分布式计算模型，由 Google 在2004年提出，主要用于处理和生成大规模数据集。...这不仅是大数据处理的基础，也是许多现代数据密集型应用开发的关键技能。
使用MapReduce编程模型进行大规模文本处理
# 1. 简介 ## 1.1 MapReduce编程模型概述 ...然而，大规模文本处理涉及到数据规模大、计算密集型和IO密集型的特点，常常会面临计算性能、数据倾斜、计算并行度等挑战。 接下来，我们将具体介绍MapRe
用MapReduce进行数据密集型文本处理 – 本地聚合（上）
小小八卦姐的专栏
10-05 1351
本文译自Working Through Data-Intensive Text Processing with MapReduce 因为最近忙于Coursera提供 的一些课程，我已经有一段时间没有写博客了。这些课程非常有意思，值得一看。我买了一本书《Data-Intensive Processing with MapReduce》，作者是Jimmy和Chris Dyer。书里以伪码形式
聊聊MapReduce处理过程中的数据类型与数据格式
weixin_34072857的博客
08-01 2291
MapReduce处理过程总览 对于MP的处理过程我想大部分人都已经知道了其原理，思路不难，这是肯定的，但是整个过程中需要考虑的细枝末节的点还挺多的，MP的输入输出格式就是其中的一点，那本文就带领大家看看MP中的格式设置问题。 map函数，起到了如下的转换作用：map：(k1,v1)—>list(k2,v2) reduce 函数，则起到了这样的格...
创建 MapReduce 查询来处理特定类型的数据
Microcoder IT之路
07-17 843
资料来源：
MapReduce：通过数据密集型文本处理
最佳 Java 编程
05-12 327
自上次发布以来已经有一段时间了，因为我一直在忙于Coursera提供的一些课程。 有一些非常有趣的产品，值得一看。 前一段时间，我购买了Jimmy Lin和Chris Dyer的MapReduce数据密集型处理程序 。 本书以伪代码格式介绍了几种关键的MapReduce算法。 我的目标是采用第3-6章中介绍的算法，并以Hadoop： Tom White的《权威指南》为参考在Hadoop中实现...
mapreduce 聚合_MapReduce：处理数据密集型文本处理–局部聚合第二部分
最佳 Java 编程
06-04 337
mapreduce 聚合 这篇文章继续进行有关使用MapReduce进行数据密集型处理的书中实现算法的系列文章。 第一部分可以在这里找到。 在上一篇文章中，我们讨论了使用本地聚合技术来减少通过网络进行混洗和传输的数据量的方法。 减少传输的数据量是提高MapReduce作业效率的主要方法之一。 单词计数MapReduce作业用于演示本地聚合。 由于结果只需要总数，因此我们可以为合并器重新使用相同...
Hadoop大数据开发基础系列：五、MapReduce进阶编程
Nelson_hehe的博客
10-18 6137
五、MapReduce进阶编程 目录： 1.筛选日志文件并生成序列化文件 2.HadoopJavaAPI读取序列化日志文件 3.优化日志文件统计程序 4.Eclipse提交日志文件统计程序 5.小结 6.实训 7.小练习 任务背景：网站运营方又提出来新的需求，为了比较今年与去年同期的用户访问数据，要求分别统计出2016年1月与2月的用户访问次数，并输出到不同的目录中。在本章中...
Hadoop MapReduce 的类型与格式 （MapReduce Types and Formats）
devalone 的专栏
06-15 1342
Hadoop    MapReduce 的类型与格式 （MapReduce Types and Formats） 1 MapReduce 类型 （MapReduce Types） Hadoop 的 MapReduce 中的 map 和 reduce 函数遵循如下一般性格式：     map: (K1, V1) → list(K2, V2)     reduce: (K2, list(V...
"MapReduce计算模型下数据倾斜处理方法研究: HVBR-SH算法
总的来说，本文在对MapReduce计算模型下数据倾斜处理方法进行研究的基础上，提出了HVBR-SH算法，该算法通过引入多个虚拟桶进行数据重分区操作，有效避免了Hash分区策略易引发的Reduce阶段数据倾斜问题。该算法在实验...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值