Top N彻底解秘
1、基础top N算法
2、分组top N算法
只要是改变每一行列的数据,一般都是用map操作,下面是基础topN算法。
package com.tom.spark.cores
import org.apache.spark.{SparkConf, SparkContext}
/**
* TopNBasic.scala
*/
object TopNBasic {
def main(args: Array[String]) {
val conf = new SparkConf().setAppName("Top N Basically!").setMaster("local")
val sc = new SparkContext(conf)
// 以下注释内容因为得到的top5不是RDD(take不返回RDD),所以重新写了能得到RDD的
// val lines = sc.textFile("F:\\sparkData\\basicTopN.txt")
// val pairs = lines.map(line => (line.toInt, line)) //生成Key-Value键值对以方便sortByKey进行排序,Int已经实现了排序比较的接口
// val sortedPairs = pairs.sortByKey(false) //降序排序
// val sortedData = sortedPairs.map(_._2) //过滤出排序后的内容本身
// val top5 = sortedData.map(_.take(5)) //获取排名前5位的元素内容,元素内容构建成为一个Array
val lines = sc.textFile("F:\\sparkData\\basicTopN.txt")
val top5 = lines.map(line => ("tmpKey", line)).groupByKey().flatMap(_._2.toList.sortWith(_ > _).take(5))
top5.collect().foreach(println)
}
}
找出每种类型数据中的topN
先按类型分组,然后再排序
//Java实现
/**
*
*/
package com.tom.spark.SparkApps.cores;
import java.util.Arrays;
import java.util.Iterator;
import org.apache.spark.SparkConf;
import org.apache.spark.api.java.JavaPairRDD;
import org.apache.spark.api.java.JavaRDD;
import org.apache.spark.api.java.JavaSparkContext;
import org.apache.spark.api.java.function.PairFunction;
import org.apache.spark.api.java.function.VoidFunction;
import scala.Tuple2;
/**
* 使用java开发topN程序
*
*/
public class TopNGroup {
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
SparkConf conf = new SparkConf().setAppName("Top N Group").setMaster("local");
JavaSparkContext sc = new JavaSparkContext(conf);
JavaRDD<String> lines = sc.textFile("F:\\sparkData\\topNGroup.txt");
//把每行数据变成符合要求的<Key,Value>格式
JavaPairRDD<String, Integer> pairs = lines.mapToPair(new PairFunction<String, String, Integer>() {
/**
*
*/
private static final long serialVersionUID = 1L;
public Tuple2<String, Integer> call(String line) throws Exception {
// TODO Auto-generated method stub
String[] splitedLine = line.split(" ");
return new Tuple2<String, Integer>(splitedLine[0], Integer.valueOf(splitedLine[1]));
}
});
JavaPairRDD<String, Iterable<Integer>> groupedPairs = pairs.groupByKey(); //对数据进行分组
JavaPairRDD<String, Iterable<Integer>> top5 = groupedPairs.mapToPair(new PairFunction<Tuple2<String,Iterable<Integer>>, String, Iterable<Integer>>() {
/**
*
*/
private static final long serialVersionUID = 1L;
public Tuple2<String, Iterable<Integer>> call(
Tuple2<String, Iterable<Integer>> groupedData) throws Exception {
// TODO Auto-generated method stub
Integer[] top5 = new Integer[5]; //保存top5的数据本身
String groupedKey = groupedData._1; //获取分组的组名
Iterator<Integer> groupedValue = groupedData._2.iterator(); //获取每组的内容集合
while(groupedValue.hasNext()) { //查看是否有下一个元素,如果继续进行循环
Integer value = groupedValue.next(); //获取当前循环元素本身的内容
for(int i = 0; i < 5; i++) { //具体实现分组内部的topN
,采用冒泡排序
if(top5[i] == null) {
top5[i] = value;
break;
}
else if(value > top5[i]) {
for(int j = 4; j > i; j--) {
top5[j] = top5[j - 1];
}
top5[i] = value;
break;
}
}
}
return new Tuple2<String, Iterable<Integer>>(groupedKey, Arrays.asList(top5));
}
});
//打印分组后的Top N
top5.foreach(new VoidFunction<Tuple2<String,Iterable<Integer>>>() {
/**
*
*/
private static final long serialVersionUID = 1L;
public void call(Tuple2<String, Iterable<Integer>> topped) throws Exception {
// TODO Auto-generated method stub
System.out.print("Group key : " + topped._1 + " : "); //获取Group Key
Iterator<Integer> toppedValue = topped._2.iterator(); //获取Group Value
while(toppedValue.hasNext()) { //具体打印出每组的Top N
Integer value = toppedValue.next();
System.out.print(value+ " ");
}
System.out.println();
}
});
sc.close();
}
}
//scalas实现
package com.tom.spark.cores
import org.apache.spark.{SparkConf, SparkContext}
/**
*
*/
object TopNGroup {
def main(args: Array[String]) {
val conf = new SparkConf().setAppName("Top N Basically!").setMaster("local")
val sc = new SparkContext(conf)
val lines = sc.textFile("F:\\sparkData\\topNGroup.txt")
val pairs = lines.map(line => {
val splited = line.split(" ")
(splited(0),splited(1).toInt)
}) //生成Key-Value键值对以方便sortByKey进行排序,Int已经实现了排序比较的接口
val groupedPairs = pairs.groupByKey() //降序排序
val sortedPairs = groupedPairs.sortByKey().map(pair =>
(pair._1,pair._2.toList.sortWith(_ > _).take(5)))
sortedPairs.collect().foreach(pair => {
println(pair._1 + " : " + pair._2)
})
}
}
RangePartitioner
RangePartitioner主要是把依赖的RDD的数据分成不同的范围,关键的是不同的范围是有序的
Google的面试题:如何在一个不确定数据规模的范围内进行排序
水塘抽样:从集合中选取具体个数的样本。适合于内存容纳不下的数据量。
N很大,从N中K个抽样的数据。
RangePartitioner就是采用了这个水塘抽样的方法
在1.1版本以前,sortByKey会触发两个job,现在只触发一个job
HashPartitioner弊端,数据倾斜,极端情况下某(几)个分区拥有RDD的所有数据!
RangePartitioner除了是结果有序的基石以外,最为重要的是尽量保证每个Partition中的数据量是均匀的
下面是采样:
val sampleSizePerPartition = math.ceil(3.0 * sampleSize / rdd.partitions.size).toInt
依赖的RDD可能数据不均匀,乘3的目的是数据量特别少的分区能抽取到足够的数据,同时保证数据量特别大的分区能够二次采样
sketch中
(Long, Array[(Int, Long, Array[K])])
Int 分区编号, Long 分区中总元素的个数, Array[K]从副RDD中每个分区中采样到的数据
reservoirSampleAndCount水塘采样
返回:(reservoir, l) 其中l记录了分区中的元素的总和
重新采样的情况:
if (fraction * n > sampleSizePerPartition) {
imbalancedPartitions += idx
}
确定具体的Key属于哪个分区partition = binarySearch(rangeBounds, k)