MapReduce-TopK

最新推荐文章于 2024-08-10 03:01:54 发布
最新推荐文章于 2024-08-10 03:01:54 发布
阅读量596 收藏 2
点赞数
分类专栏： hadoop MapReduce 文章标签： hadoop MapReduce

友情提示：更多有关大数据、人工智能方面技术文章请关注博主个人微信公众号：高级大数据架构师！

上一篇博客中简单的写了一个MapReduce的程序，其中只重写了map()和reduce()方法，但里面还有cleanup(Context context)，
setup(Context context）和run(Context context)方法可以可以重写
这一个实例，我们就说明一下cleanup(Context context)，setup(Context context）这两个方法的作用以及在本例中的用法，
以及TopK的MapReduce的写法，对于TopK这里将根据实际情况用种方法来实现，一种是只关注TopK的数值，另一种情况是不但

 

关心TopK的数值，而且还要输出TopK的相关信息

 

首先讲解setup(Context context）和cleanup(Context context)的作用
以下是hadoop1.2.1中截取换源码，位于org.apache.hadoop.mapreduce.Mapper类中

 

[java] view plain copy

  1. /** 
  2.    * Called once at the beginning of the task. 
  3.    */  
  4.   protected void setup(Context context ) throws IOException, InterruptedException {  
  5.     // NOTHING  
  6.   }  
  7.   /** 
  8.    * Called once at the end of the task. 
  9.    */  
  10.   protected void cleanup(Context context ) throws IOException, InterruptedException {  
  11.     // NOTHING  
  12.   }  

由注释可知道setup()方法是在任务开始之前调用一次，cleanup()方法则是在任务结束之后调用一次
所以这两个方法可以用来对初始的变量进行赋值，或文件的分发，以及任务执行完成过后对资源的释放
在本例中我们会用这两个方法来做TopK中K值的指定。在以后的博客中我们还会有其它的用法。


以下的代码是Mapper类中的一个重要的方法，从run()可以看到任务提交后首先执行setup(context)方法
然后通过判断是否还有下一个值，不停的调用map()方法，最后在调用cleanup(context)方法，这就是一Map执行的顺序
这里不详细讲解nextKeyValue()方法，后面在讲解RecordReader的定制的博客中会做详细的讲解，参见MapReduce-xml文件的处理-定制InputFormat及定制RecordReader。

 

 

[java] view plain copy

  1. /** 
  2.   * Expert users can override this method for more complete control over the 
  3.   * execution of the Mapper. 
  4.   * @param context 
  5.   * @throws IOException 
  6.   */  
  7.  public void run(Context context) throws IOException, InterruptedException {  
  8.    setup(context);  
  9.    try {  
  10.     //map通过这里反复调用RecordReader的方法  
  11.     while (context.nextKeyValue()) {  
  12.     //context.getCurrentKey()在MapContext的方法中调用相关RecordReader的方法  
  13.         /** 
  14.          * @Override 
  15.          *      public KEYIN getCurrentKey() throws IOException, InterruptedException { 
  16.          *          return reader.getCurrentKey(); 
  17.          *      } 
  18.          */  
  19.        map(context.getCurrentKey(), context.getCurrentValue(), context);  
  20.      }  
  21.    } finally {  
  22.      cleanup(context);  
  23.    }  
  24.  }  

接下来我们开始写TopK的第一个情况的程序
测试数据：
uid,name,cost
1,mr1,3234
2,mr2,123
3,mr3,9877
4,mr4,348
5,mr5,12345
6,mr6,6646
7,mr7,98
8,mr8,12345
现在要提取出消费最高的金额前3的是多少
map阶段：

 

[java] view plain copy

  1. import java.io.IOException;  
  2. import java.util.Arrays;  
  3. import org.apache.hadoop.io.IntWritable;  
  4. import org.apache.hadoop.io.LongWritable;  
  5. import org.apache.hadoop.io.Text;  
  6. import org.apache.hadoop.mapreduce.Mapper;  
  7.   
  8. public class TopKMapper extends Mapper<LongWritable, Text, IntWritable, IntWritable> {  
  9.       
  10.     int len;  
  11.     int[] tmp;  
  12.   
  13.     /** 
  14.      * Map任务启动的时候调用 
  15.      */  
  16.     @Override  
  17.     protected void setup( Context context)  
  18.             throws IOException, InterruptedException {  
  19.         /** 
  20.          * 通过context获取任务启动时传入的TopK的K值 
  21.          */  
  22.         len = context.getConfiguration().getInt("K", 10);  
  23.         /** 
  24.          * 创建一个数组来存放topK的值 
  25.          */  
  26.         tmp = new int[len + 1];  
  27.     }  
  28.   
  29.     @Override  
  30.     protected void map(LongWritable key, Text value, Context context)  
  31.             throws IOException, InterruptedException {  
  32.         String line = value.toString();  
  33.         String[] arr = line.split(",");  
  34.         if(arr.length == 3) {  
  35.             addParm(Integer.valueOf(arr[2]));  
  36.         }  
  37.     }  
  38.     /** 
  39.      * 把新取出的数值放到数组中的第一位，并按从小到大排序 
  40.      * 这样下一次放入时就把最小的数值去除掉了 
  41.      */  
  42.     private void addParm(int parm) {  
  43.         tmp[0] = parm;  
  44.         Arrays.sort(tmp);  
  45.     }  
  46.       
  47.     @Override  
  48.     protected void cleanup(Context context)  
  49.             throws IOException, InterruptedException {  
  50.         /** 
  51.          * 把数组中的数值倒序的输出，这样每个Map就输出了自己的TOPK去reduce端 
  52.          */  
  53.         for( int i = 1 ; i <= len ; i ++) {  
  54.             context.write(new IntWritable(tmp[i]), new IntWritable(tmp[i]));  
  55.         }  
  56.     }  
  57. }  

reduce阶段：

 

 

[java] view plain copy

  1. import java.io.IOException;  
  2. import java.util.Arrays;  
  3. import org.apache.hadoop.io.IntWritable;  
  4. import org.apache.hadoop.mapreduce.Reducer;  
  5.   
  6. public class TopKReducer extends Reducer<IntWritable, IntWritable, IntWritable, IntWritable> {  
  7.     int len;  
  8.     int[] tmp;  
  9.       
  10.     @Override  
  11.     protected void setup( Context context)  
  12.             throws IOException, InterruptedException {  
  13.         len = context.getConfiguration().getInt("K", 10);  
  14.         tmp = new int[len + 1];  
  15.     }  
  16.   
  17.     @Override  
  18.     protected void reduce(IntWritable key, Iterable<IntWritable> values, Context arg2)  
  19.             throws IOException, InterruptedException {  
  20.         for(IntWritable value: values) {  
  21.             addParm(value.get());  
  22.         }  
  23.     }  
  24.   
  25.     private void addParm(int parm) {  
  26.         tmp[0] = parm;  
  27.         Arrays.sort(tmp);  
  28.     }  
  29.       
  30.     @Override  
  31.     protected void cleanup( Context context)  
  32.             throws IOException, InterruptedException {  
  33.         for( int i = len; i > 0 ; i --) {  
  34.             context.write(new IntWritable(len - i + 1), new IntWritable(tmp[i]));  
  35.         }  
  36.     }  
  37. }  

启动函数：

 

 

[java] view plain copy

  1. import org.apache.hadoop.conf.Configuration;  
  2. import org.apache.hadoop.fs.FileSystem;  
  3. import org.apache.hadoop.fs.Path;  
  4. import org.apache.hadoop.io.IntWritable;  
  5. import org.apache.hadoop.mapreduce.Job;  
  6. import org.apache.hadoop.mapreduce.lib.input.FileInputFormat;  
  7. import org.apache.hadoop.mapreduce.lib.output.FileOutputFormat;  
  8.   
  9. public class JobMain {  
  10.     public static void main(String[] args) throws Exception {  
  11.         Configuration configuration = new Configuration();  
  12.         /** 
  13.          * 把传入参数放入Configuration中，map或reduce中可以通过 
  14.          * 获取Configuration来获取传入的参数，这是hadoop传入参数的 
  15.          * 方式之一 
  16.          */  
  17.         configuration.set("K", args[2]);  
  18.         Job job = new Job(configuration, "topK-job");  
  19.         job.setJarByClass(JobMain.class);  
  20.         job.setMapperClass(TopKMapper.class);  
  21.         job.setMapOutputKeyClass(IntWritable.class);  
  22.         job.setMapOutputValueClass(IntWritable.class);  
  23.         job.setReducerClass(TopKReducer.class);  
  24.         job.setOutputKeyClass(IntWritable.class);  
  25.         job.setOutputValueClass(IntWritable.class);  
  26.         FileInputFormat.addInputPath(job, new Path(args[0]));  
  27.         Path outputDir = new Path(args[1]);  
  28.         FileSystem fs = FileSystem.get(configuration);  
  29.         if(fs.exists(outputDir)) {  
  30.             fs.delete(outputDir, true);  
  31.         }  
  32.         FileOutputFormat.setOutputPath(job, outputDir);  
  33.         System.exit(job.waitForCompletion(true)? 0: 1);  
  34.     }  
  35. }  

 

 

测试结果：

 

 

 

测试数据：
uid,name,cost
1,mr1,3234
2,mr2,123
3,mr3,9877
4,mr4,348
5,mr5,12345
6,mr6,6646
7,mr7,98
8,mr8,12345
现在要提取出消费最高的金额前3的name加金额

map阶段：

 

[java] view plain copy

  1. import java.io.IOException;  
  2. import java.util.Map.Entry;  
  3. import java.util.Comparator;  
  4. import java.util.Set;  
  5. import java.util.TreeMap;  
  6. import org.apache.hadoop.io.IntWritable;  
  7. import org.apache.hadoop.io.LongWritable;  
  8. import org.apache.hadoop.io.Text;  
  9. import org.apache.hadoop.mapreduce.Mapper;  
  10.   
  11. public class TopKTreeMapper extends  
  12.         Mapper<LongWritable, Text, IntWritable, Text> {  
  13.   
  14.     private int len;  
  15.     private TreeMap<Integer, String> tmp;  
  16.     private IntWritable key = new IntWritable();  
  17.     private Text value = new Text();  
  18.     /** 
  19.      * Map任务启动的时候调用 
  20.      */  
  21.     @Override  
  22.     protected void setup(Context context) throws IOException,  
  23.             InterruptedException {  
  24.         /** 
  25.          * 通过context获取任务启动时传入的TopK的K值 
  26.          */  
  27.         len = context.getConfiguration().getInt("K", 10);  
  28.         tmp = new TreeMap<Integer, String>(new Comparator<Integer>() {  
  29.   
  30.             @Override  
  31.             public int compare(Integer o1, Integer o2) {  
  32.                 return o2-o1;  
  33.             }  
  34.         });  
  35.     }  
  36.   
  37.     @Override  
  38.     protected void map(LongWritable key, Text value, Context context)  
  39.             throws IOException, InterruptedException {  
  40.         String line = value.toString();  
  41.         String[] arr = line.split(",");  
  42.         if (arr.length == 3) {  
  43.             addParm(Integer.valueOf(arr[2]), arr[1]);  
  44.         }  
  45.     }  
  46.   
  47.     /** 
  48.      * 把新取出的数值放到数组中的第一位，并按从小到大排序 这样下一次放入时就把最小的数值去除掉了 
  49.      */  
  50.     private void addParm(int parm, String name) {  
  51.         tmp.put(parm, name);  
  52.         if (tmp.size() > len) {  
  53.             tmp.remove(tmp.lastKey());  
  54.         }  
  55.     }  
  56.   
  57.     @Override  
  58.     protected void cleanup(Context context) throws IOException,  
  59.             InterruptedException {  
  60.         Set<Entry<Integer, String>> set = tmp.entrySet();  
  61.         for (Entry<Integer, String> entry : set) {  
  62.             key.set(entry.getKey());  
  63.             value.set(entry.getValue());  
  64.             context.write(key, value);  
  65.         }  
  66.     }  
  67. }  

reduce阶段：

 

 

[java] view plain copy

  1. import java.io.IOException;  
  2. import java.util.Map.Entry;  
  3. import java.util.Comparator;  
  4. import java.util.Set;  
  5. import java.util.TreeMap;  
  6. import org.apache.hadoop.io.IntWritable;  
  7. import org.apache.hadoop.io.Text;  
  8. import org.apache.hadoop.mapreduce.Reducer;  
  9.   
  10. public class TopKTreeReducer extends Reducer<IntWritable, Text, Text, IntWritable> {  
  11.     int len;  
  12.     private TreeMap<Integer, String> tmp;  
  13.     private IntWritable key = new IntWritable();  
  14.     private Text value = new Text();  
  15.       
  16.     @Override  
  17.     protected void setup( Context context)  
  18.             throws IOException, InterruptedException {  
  19.         len = context.getConfiguration().getInt("K", 10);  
  20.         tmp = new TreeMap<Integer, String>(new Comparator<Integer>() {  
  21.             @Override  
  22.             public int compare(Integer o1, Integer o2) {  
  23.                 return o2-o1;  
  24.             }  
  25.         });  
  26.     }  
  27.   
  28.     @Override  
  29.     protected void reduce(IntWritable key, Iterable<Text> values, Context arg2)  
  30.             throws IOException, InterruptedException {  
  31.         for(Text value : values) {  
  32.             addParm(key.get(), value.toString());  
  33.         }  
  34.     }  
  35.   
  36.     private void addParm(int parm, String name) {  
  37.         tmp.put(parm, name);  
  38.         if (tmp.size() > len) {  
  39.             tmp.remove(tmp.lastKey());  
  40.         }  
  41.     }  
  42.       
  43.     @Override  
  44.     protected void cleanup( Context context)  
  45.             throws IOException, InterruptedException {  
  46.         Set<Entry<Integer, String>> set = tmp.entrySet();  
  47.         for (Entry<Integer, String> entry : set) {  
  48.             key.set(entry.getKey());  
  49.             value.set(entry.getValue());  
  50.             context.write(value, key);  
  51.         }  
  52.     }  
  53. }  

启动函数：

 

 

[java] view plain copy

  1. import org.apache.hadoop.conf.Configuration;  
  2. import org.apache.hadoop.fs.FileSystem;  
  3. import org.apache.hadoop.fs.Path;  
  4. import org.apache.hadoop.io.IntWritable;  
  5. import org.apache.hadoop.io.Text;  
  6. import org.apache.hadoop.mapreduce.Job;  
  7. import org.apache.hadoop.mapreduce.lib.input.FileInputFormat;  
  8. import org.apache.hadoop.mapreduce.lib.output.FileOutputFormat;  
  9.   
  10. public class JobMainTree {  
  11.     public static void main(String[] args) throws Exception {  
  12.         Configuration configuration = new Configuration();  
  13.         /** 
  14.          * 把传入参数放入Configuration中，map或reduce中可以通过 
  15.          * 获取Configuration来获取传入的参数，这是hadoop传入参数的 
  16.          * 方式之一 
  17.          */  
  18.         configuration.set("K", args[2]);  
  19.         Job job = new Job(configuration, "topK-job-tree");  
  20.         job.setJarByClass(JobMainTree.class);  
  21.         job.setMapperClass(TopKTreeMapper.class);  
  22.         job.setMapOutputKeyClass(IntWritable.class);  
  23.         job.setMapOutputValueClass(Text.class);  
  24.         job.setReducerClass(TopKTreeReducer.class);  
  25.         job.setOutputKeyClass(Text.class);  
  26.         job.setOutputValueClass(IntWritable.class);  
  27.         FileInputFormat.addInputPath(job, new Path(args[0]));  
  28.         Path outputDir = new Path(args[1]);  
  29.         FileSystem fs = FileSystem.get(configuration);  
  30.         if(fs.exists(outputDir)) {  
  31.             fs.delete(outputDir, true);  
  32.         }  
  33.         FileOutputFormat.setOutputPath(job, outputDir);  
  34.         System.exit(job.waitForCompletion(true)? 0: 1);  
  35.     }  
  36. }  

运行结果：

 



结论：如果仔细观察结果会发现，第二次运行结果没有重复的最大值出现，重复的值只出现了一次而且是最新进入TreeMap的值，这是因为TreeMap的属性的问题，这里我们不做过多的讨论，这篇博客只是熟悉Mapper类中可重写方法的用途。下一篇博客讲解自定义输入类型，并解决这一篇遗留的即要取name字段又要取cost字段，但还要保留做重复金额的问题。

大数据爱好者社区
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
MapReduce实现TopK的示例
我与大象的故事
08-21 994
由于开始学习MapReduce编程已经有一段时间了，作为一个从编程中寻找自信和乐趣以及热爱编程的孩子来讲，手开始变得很“痒”了，很想小试一下身手。于是自己编写了TopK的代码。TopK的意思就是从原文件中找出词频排名前K的所有单词。首先分析该问题，从中我们可以得到启发：要想知道词频排名前K的所有单词，那么是不是要对所有的单词进行词频的统计啊？于是我们就联想到了一个比较经典的例子：WordCount
MapReduce---TopN
XiaodunLP的博客
02-14 200
package com.mapreduce.topn; import org.apache.hadoop.io.Text; public class Item implements Comparable&lt;Item&gt;{ private Long count; private String content; public Item() { } ...
MapReduce编程之求Top3（TopN）
11-26
已知有若干个文件（多个），文件中包含若干个正整数，每行一个，示例如下： 45 3 78 456 70 1 999 。。。 编写MR程序分别求解所有文件中最大的三个值（TOP 3）
TopK问题--MapReduce处理
qq_28027543的博客
12-23 177
原始数据 分为8个block存储，847 MB 数据格式：每个数字是[0,1亿）区域内的随机数(存储的byte长度也不一样，比如：随机数1只用一个byte存储字符1 ; 随机数200 则需要3个字符存储)，之间用空格分开。 InputFormat设置 根据数据格式设计分割方式：根据cpu最多并行12线程，应该分割为12个split，开启12个mapTask同时读数据。每条record之...
MapReduce实现TopK算法 原理及代码
airyv的博客
07-18 783
1、map阶段 通过map方法将数据构造成数据小于K的TreeMap，在每次map后判断TreeMap的大小和K的大小，当TreeMap的数据量大于K时，取出最小的数。在map结束后会执行cleanup方法，该方法将map中的前K个数据传入reduce任务中。 2、reduce阶段 在 reduce方法中，依次将map方法中传入K个数据放入 TreeMap中，从而将K个数 据利用红黑树的 firstKey方法按从大到小者利用红黑树的 lastKey方法按从小到大的顺序 排列。从而求出前K个数。 3、代码部分
基于MapReduce的TOP-K查询问题的实现
believe_stone的博客
01-15 3419
TreeMap存储前K个数据 如何存储前K个数据是TopK问题的一大核心问题，这里采用Java中TreeMap来进行存储。TreeMap的实现是红黑树算法的实现，红黑树又称红-黑二叉树，它首先是一棵二叉树，它具体二叉树所有的特性，同时红黑树更是一棵自平衡的排序二叉树。平衡二叉树必须具备如下特性：它是一棵空树或它的左右两个子树的高度差的绝对值不超过1，并且左右两个子树都是一棵平衡二叉树。也就是说该
论文研究-基于MapReduce的top-.pdf
07-22
为了解决这两个问题，基于MapReduce的top-k高效用模式挖掘算法（TKHUP_MaR）被提出。该算法通过两次扫描数据库，利用三次MapReduce来实现并行top-k高效用模式的挖掘。通过实验表明TKHUP_MaR 算法在并行挖掘top-k高效...
MapReduce中高效的Top-k天际线计算
03-12
MapReduce中高效的Top-k天际线计算
基于MapReduce方法统计服务器日志topk数据.zip
03-13
这个项目名为"TopK-Log-Map-Reduce-master"，它揭示了如何利用分布式计算技术处理海量日志数据，找出出现频率最高的前K个元素，这在诸如网站分析、用户行为追踪或异常检测等场景中非常有用。 MapReduce是一种编程...
java操作hadoop之mapreduce计算整数的最大值和最小值实战源码
02-03
java操作hadoop之mapreduce计算整数的最大值和最小值实战源码，附带全部所需jar包，欢迎下载一起学习。
MapReduce环境下面向用户偏好的top-k连接查询处理方法
02-07
### MapReduce环境下面向用户偏好的top-k连接查询处理方法 #### 一、研究背景与意义 随着互联网技术的快速发展和大数据时代的到来，如何高效地处理海量数据成为了研究的热点。传统的数据库管理系统难以应对大数据...
基于MapReduce实现物品协同过滤算法（ItemCF）
04-18
5. **相似度计算**：在Reduce阶段，我们计算每对物品的相似度，这一步可能涉及到一些优化技巧，如采样或者Top-K策略，以减少计算量。 6. **推荐生成**：最后，对于每个用户，我们找出其已评分物品的相似物品，并...
Hadoop读书笔记（十四）MapReduce中TopK算法（Top100算法）
caicongyang
12-11 5147
Hadoop1.x中MapReduce中TopK算法（Top100算法）
hadoop-MapReduce 实现TopK的方法
Chain的博客
07-08 776
（1）本文的目的是对搜狗的用户查询日志的利用sum进行排序，选出搜索比较热的一些查询，语料集如下： 列名分别为 访问时间\t用户ID\t[查询词]\t该URL在返回结果中的排名\t用户点击的顺序号\t用户点击的URL （2）这里实现分为了三种方式去实现 （2.1）第一种，利用TreeMap与重写cleanUp进行实现，个人觉得这是最简单的一种方法了，但是它有一定的缺点，缺点在后面会提到，...
MapReduce实现TopK
龙崎的专栏
03-23 3343
Hadoop inaction上面的练习。 刚开始考虑，每个分片应该是在所有的记录处理完之后，把这个分片的前K大输出给reduce，但是map函数是每个记录调用一遍，把怎么在所有记录调用完之后处理呢？ setup()，此方法被MapReduce框架仅且执行一次，在执行Map任务前，进行相关变量或者资源的集中初始化工作。若是将资源初始化工作放在方法map()中，导致Mapper任务在解析每一
MapReduce TopK问题实际应用
lavimer
01-28 4253
一：背景 TopK问题应该是海量数据处理中应用最广泛的了，比如在海量日志数据处理中，对数据清洗完成之后统计某日访问网站次数最多的前K个IP。这个问题的实现方式并不难，我们完全可以利用MapReduce的Shuffle过程实现排序，然后在Reduce端进行简单的个数判断输出即可。这里还涉及到二次排序，不懂的同学可以参考我之前的文章。 二：技术实现 #我们先来看看一条Ngnix服务器的日
Hadoop入门（二十四）Mapreduce的求TopK程序
茅坤宝骏氹的博客
10-20 835
一、简介 求TopK是算法中最常使用到的，现在使用Mapreduce在海量数据中统计数据的求TopK。 二、例子 （1）实例描述 给出三个文件，每个文件中都存储了若干个数值，求所有数值中的求Top 5。 样例输入： 1）file1： 1 2 3 7 9 -99 2 2）file2： ...
C# Binding
最新发布
weixin_43751677的博客
08-10 705
WPF编程宝典 结合 WPF深入浅出 学习 数据绑定
海量数据处理面试题与方法总结：Top10挑战
4. **TopK问题**：这是一个常见的数据挖掘问题，要求找出前K个最常见的元素。在搜索引擎日志分析的场景中，我们需要找到最热门的10个查询串。一种解决方案是使用最小堆，它能在O(K)的空间复杂度内保持K个最小元素，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值