spark如何进行聚类可视化_利用spark做文本聚类分析

聚类分析

什么是聚类分析？《数据挖掘导论》是给出了这样的定义：聚类分析仅根据在数据中发现的描述对象及其关系的信息，将数据对象分组。其目标是，组内的对象相互之间是相似的(相关的)，而不同组中的对象是不同(不相关的)。组内的相似性(同质性)越大，组间差别越大，聚类就越好。

想像有这样的一个情景：用户每天都会通过搜索引擎去查询他/她所感兴趣的信息，而我们希望能够根据用户的搜索词去细分目标用户群体，从而分析不同用户群体对哪些信息比较感兴趣。这时，聚类分析就是我们常常采用的手段。

高斯混合分布聚类模型

除了常见的基于距离的聚类模型，如k-means聚类，聚类中也有基于概率模型，例如高斯混合分布聚类模型(GMM)。基于概率模型的好处在于，它并没有像k-means那样让每一个数据点只能归属于一个簇当中，而是通过概率来反映每个数据点可能分布到每一个簇的概率值，即属于软聚类。在某些场景中，软聚类能够解释数据点的多元性，好比如人的兴趣点不唯一，用户行为的多样性等等。 高斯混合分布模型主要是利用EM算法做参数估计，关于高斯混合分布聚类模型的详细讲述，我将其放到另一份博客当中： http://blog.csdn.net/qq_30843221/article/details/54894640

聚类模型的详细过程

1.样本数据 我们模拟用户搜索行为，一组是搜索关于电影内容，而另一组是关于机器学习，具体数据如下：好看 电影 惊悚 悬疑 不错 推荐 机器学习 自然语言处理 信息 检索 机器学习 数据挖掘 人工智能 检索 电影 动画 精彩 好看 不错 加油 推荐

2.数据的加载，基本的分词(我使用的java版的spark，分词工具为hanlp)//加载数据

String filename = "/home/quincy1994/test.txt";

JavaRDD sentences = sc.textFile(filename);

JavaRDD segRDD = sentences.map(new Seg());

JavaRDD jrdd = segRDD.map(new StringtoRow());

segRDD.cache();

//数据转换为矩阵

StructType schema = new StructType(new StructField[]{

new StructField("sentence", DataTypes.StringType, false, Metadata.empty())

});

DataFrame sentenceData = sqlContext.createDataFrame(jrdd, schema);

Tokenizer tokenizer = new Tokenizer().setInputCol("sentence").setOutputCol("words"); //tokenizer以简单的空白分割词语

DataFrame wordsData = tokenizer.transform(sentenceData); // 将句子分割词语

//分词类

static class Seg implements Function{

public String call(String sentence) throws Exception{

String segStr = "";

List termList = segment.seg(sentence); //分词

StringBuilder sb = new StringBuilder();

for(Term term: termList){

String word = term.word;

sb.append(word+ " ");

}

segStr = sb.toString().trim();

return segStr;

}

}

//将String的sentence转变为mllib中row数据类型

static class StringtoRow implements Function{

public Row call(String sentence) throws Exception {

return RowFactory.create(sentence);

}

}1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

3.特征选择(我主要采用的tfidf模型，刚开始使用word2vec不太理想，可能数据太稀疏)//tfidf模型

int numFeatures = 20; //选定抽取前k个特征

HashingTF hashingTF = new HashingTF().setInputCol("words").setOutputCol("rawFeatures").setNumFeatures(numFeatures);

DataFrame featurizedData = hashingTF.transform(wordsData);

IDF idf = new IDF().setInputCol("rawFeatures").setOutputCol("features");

IDFModel idfModel = idf.fit(featurizedData);

DataFrame result = idfModel.transform(featurizedData);1

2

3

4

5

6

7

4.数据的归一化处理(之前忘了做这步，也导致数据聚类效果不理想)//归一化处理

Normalizer normalizer = new Normalizer().setInputCol("features").setOutputCol("normFeatures").setP(1.0);

DataFrame l1NormData = normalizer.transform(result.select("features"));

JavaRDD normRDD = l1NormData.rdd().toJavaRDD().map(new RowToVector()); //将row转变成为vector

normRDD.cache();

//将row转变为Vector,机器学习模型基本采用vector类型

static class RowToVector implements Function{

public Vector call(Row r) throws Exception {

// TODO Auto-generated method stub

Vector features = r.getAs(0); //将row转变成为vector

return features;

}

}1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

5.使用高斯混合模型聚类(代码超简单)static int k = 2; //设定有多少个高斯混合模型

GaussianMixtureModel gmm = new GaussianMixture().setK(k).run(normRDD.rdd());

normRDD.cache();1

2

3

6.为每个节点标记它归属的簇//为每个节点标记归属的簇

RDD points = normRDD.rdd();

JavaRDD predictRDD = new JavaRDD(gmm.predictSoft(points), null);

JavaRDD resultRDD = predictRDD.map(new Group());

resultRDD.cache();

static class Group implements Function{

//我设定归属概率大于0.5的簇，否则当其为噪声

public Integer call(double[] probabilities) throws Exception {

double max = 0.5;

int index = -1;

for(int i = 0; i < probabilities.length; i++){

if(max <= probabilities[i]){

index = i;

break;

}

}

return index;

}

}1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

7.从每个簇中提取主要标签词//在每个簇中提取主标签

Object[] output= resultRDD.collect().toArray(); //得到每个数据点属于的簇

Object[] seg = segRDD.collect().toArray(); //得到每个数据点原来的标签词

//集合不同簇各自的标签词

List> list = new ArrayList>();

for(int i = 0; i

int group = (Integer) output[i];

String tags = (String) seg[i];

Tuple2 one = new Tuple2(group, tags);

list.add(one);

}

JavaPairRDD rddValue = sc.parallelizePairs(list);

JavaPairRDD> groupRDD = rddValue.groupByKey(); //按簇归类

JavaRDD> tagsRDD = groupRDD.map(new ReduceString()); //将不同的标签混合在一块

JavaRDD> topKRDD = tagsRDD.map(new TopTag()); //找出前k个具有代表性的标签

static class ReduceString implements Function>, Tuple2>{

//合并标签词

public Tuple2 call(Tuple2> clusterString){

int key = clusterString._1();

StringBuffer sb = new StringBuffer();

Iterable iter = clusterString._2();

for( String string: iter){

sb.append(string + " ");

}

return new Tuple2(key, sb.toString().trim());

}

}

static class TopTag implements Function, Tuple2>{

//将所有的标签收集，排序，找出频率最高的前k个标签词

int topK = 3;

public Tuple2 call(Tuple2 cluster){

int key = cluster._1();

String[] taglist = cluster._2().split(" ");

Map map = new HashMap();

for(String tag: taglist){

if(!map.containsKey(tag)){

map.put(tag, 1);

}

else{

int count = map.get(tag);

map.put(tag, count + 1);

}

}

List> infolds = new ArrayList>(map.entrySet());

Collections.sort(infolds, new Comparator>(){

public int compare(Map.Entryo1, Map.Entryo2){

return (o2.getValue() - o1.getValue());

}

});

String str = "";

int num = 0;

for(Map.Entry one: infolds){

str += one.getKey() + " ";

if(num == topK){

break;

}

num += 1;

}

return new Tuple2(key, str.trim());

}

}1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

60

61

62

63

64

65

8.输出结果//输出结果

List> reducelist = topKRDD.collect();

for(Tuple2 tags: reducelist){

System.out.println(tags._1() + ":" + tags._2());

}1

2

3

4

5

结果如下：0:机器学习 检索 信息 1:电影 推荐 好看