利用spark做文本分类（朴素贝叶斯模型）_spark 文本分类

朴素贝叶斯模型

朴素贝叶斯法是基于贝叶斯定理与特征条件独立假设的分类方法。对于给定的训练数据集，首先基于特征条件独立假设学习输入/输出的联合概率分布；然后基于此模型，对给定的输入x，利用贝叶斯定理求出后验概率最大的输出y。至于朴素贝叶斯模型的原理部分，这里就不讲啦，有疑惑的朋友，我推荐看李航的《统计学习方法》中的第四章。我在这里主要谈论的是基于Java版的spark贝叶斯模型。

应用场景

相对于LR，SVM这类二元分类模型，贝叶斯模型在多元分类模型中显得更有优势的。举一个场景，我们希望能通过用户搜索的关键词来判断用户的兴趣爱好。例如用户搜索的关键词是“萌宠 猫狗”，我们通过贝叶斯模型分析出用户原来对动物是感兴趣的。

实现的过程

1.确定分类类别与训练样本及其特征
假设确定有以下的类别以及部分的特征词：

健康养生：健康养生/预防疾病/健康养生专家/膳食营养/休闲养生/健康资讯/休闲与养生
军事历史：军事历史/武器/坦克/军委主席/人类精神文明/特务/突击队/八路军/四代机/
电影：电影/电影资料库/爱情片/鹰眼/刘亦菲/葛优/动作/影片推荐/惊悚/日韩电影/港台电影/
教育：教育/英语教师/华图教育/作文/公务员培训/211/挂科/雅思/地理/申论/高校广播/
旅游：旅游/旅行游记/游记/观光/爸妈游/旅行爱好者/旅行是找寻自我/国内游/
音乐:/Kugou/钢琴/音樂/网络流行/古筝/Urban/音乐人/翻唱/酷狗/虾米音乐/
摄影：摄影/时尚摄影/时装摄影/Photography/摄影师/专题摄影/摄影/相册/相机/索尼/尼康
萌宠：萌宠/萌宠物/可爱宠物/宠物用品/猫猫狗狗宠物控/猫控/食肉动物/猫咪/喵星人/宠物用品商城/

实际中的项目有25个类别，我将其置于不同的文件中，每个类别大概有500个特征词

2.获取标签特征词

List<String> vocabulary = new ArrayList<String>();
        File dir = new File("/home/quincy1994/文档/微脉圈/tags/类别库");
        File[] files = dir.listFiles(); //获取不同类别的标签文件
        StringBuilder sb = new StringBuilder();
        for(File file : files){
            BufferedReader br = new BufferedReader(new FileReader(file));
            String line = null;
            while((line = br.readLine()) != null){
                sb.append(line + "`");  //按“`"分割不同类别的标签
            }
        }
         String[] tags = sb.toString().trim().split("`");
         List<String> newTags = new ArrayList<String>();
         for(String tag: tags){
             if(tag.length() > 4){
                 newTags.add(tag);  //去除空行标签
             }
         }
         Object[] newtags =  newTags.toArray();
         List<Tuple2<Integer, String>> list = new ArrayList<Tuple2<Integer,String>>(); //记录每类中的标签
         for(int i=0; i<newtags.length;i++){
             Tuple2 <Integer, String> classWithTags = new Tuple2<Integer, String>(i, (String)newtags[i]); 
             System.out.println(classWithTags);
             list.add(classWithTags);
             String[] tokens = ((String)newtags[i]).split("/");
             for(String tag: tokens){
                 vocabulary.add(tag);
             }
         }
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

3.获取训练样本
在获得训练样本的过程中，由于特征维度是上万维。如果为每个样本都申请上万维的向量空间，会导致jvm内存不足。为了解决这样的问题。我将训练样本转变为libsvm文件，而mllib支持libsvm文件的操作。libsvm格式文件为：【label】(空格)【index1】:【value1】(空格)【index2】:【value2】…..
其中【label】是训练数据集的目标值，对于分类，它是标识某类的整数（支持多个类）；对于回归，是任意的实数。【index】是以1开始的整数，可以是不连续的；【value】为实数，也就是我们常说的自变量。检验数据文件中的label只用于计算准确度或误差，如果它是未知的，只需用一个数填写这一栏，也可以空看不填。具体的样例如下：

+1 1:0.7 2:1 3:1 4:-0.32
-1 1:0.58 2:-1 3:0.33 4:-0.6

 //获取训练样本
     JavaPairRDD<Integer, String> trainRDD = sc.parallelizePairs(list); //将每类的标签词转化为RDD
     JavaPairRDD<Integer, String> trainSetRDD = trainRDD.mapValues(new ToTrainSet(vocabulary)); //将标签词转化为向量模型
     List<Tuple2<Integer, String>> trainSet = trainSetRDD.collect(); 
     writeTrainSet(trainSet);  //写成libsvm文件格式，以方便训练
     System.out.println("trainset is ok");

static class ToTrainSet implements Function<String, String>{
        List<String> vocabulary = null; //标签特征库
        public ToTrainSet(List<String> vocabulary){
            this.vocabulary = vocabulary;
        }
        public String call(String sentence) throws Exception {
            // TODO Auto-generated method stub
            int length = vocabulary.size();         //特征维度
            String[] tags = sentence.split("/");    
            List<Integer> tagsindex = new ArrayList<Integer>();
            for(int i =0; i<tags.length; i++){
                tagsindex.add(vocabulary.indexOf(tags[i]));
            }
            String vector = "";  //将特征向量转变为String类，节省空间
            for(int i = 0 ; i < length; i++){
                if(tagsindex.contains(i)){
                    vector += String.valueOf(1) + " ";
                }
                else{
                    vector += String.valueOf(0) + " ";
                }
            }
            return vector.trim();
        }
    }

    public static void  writeTrainSet( List<Tuple2<Integer, String>> list) throws Exception{
        File file = new File("./trainset");
        PrintWriter pr = new PrintWriter(new FileWriter(file));
        for(Tuple2<Integer, String> one : list){     //将每个训练样本以libsvm格式保存到trainset文件当中
            String label = String.valueOf(one._1);   //训练样本的类别属性
            String vector = one._2();  //训练样本的向量模型
            String[] indexes = vector.split(" ");
            pr.print(label + " ");
            String value = "";
            for(int i = 0; i<indexes.length;i++){
                value += (i+1) + ":" + indexes[i] + " ";   // i+1是因为libsvm文件的index是从1开始
            }
            pr.print(value.trim());
            pr.println();
        }
        pr.close();
    }
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

4.读取训练集并训练模型

 String path = "./trainset";
     JavaRDD<LabeledPoint> trainData = MLUtils.loadLibSVMFile(sc.sc(), path).toJavaRDD();
     model = NaiveBayes.train(trainData.rdd(), 1.0); 
//   model.save(sc.sc(), "./model");
     System.out.println("model is ok");
1
2
3
4
5

5.预测新的测试集

 String testStr = "萌宠 猫狗 ";
     double[] testArray = sentenceToArrays(vocabulary, testStr);
     writeTestSet(testArray);
     String testPath = "./testset";
     JavaRDD<LabeledPoint> testData = MLUtils.loadLibSVMFile(sc.sc(), testPath).toJavaRDD();

    public static void writeTestSet(double[] testArray) throws Exception {
        //和writeTrainSet一样
        File file = new File("./testset");
        PrintWriter pr = new PrintWriter(new FileWriter(file));
        pr.print("0" + " ");
        String value = "";
        for(int i=0; i<testArray.length; i++){
            value += (i+1) + ":" + testArray[i] + " ";
        }
        pr.print(value.trim());
        pr.close();
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

6.多元分类预测

JavaRDD<double[]> resultData = testData.map(new GetProbabilities());
     List<double[]> result = resultData.collect(); //保存的是每个测试样本所属于不同类别的概率值
     for(double[] one: result){
         for(int i=0;i<one.length;i++){
             System.out.println("class "+ i + ":" + one[i]);
         }
     }
1
2
3
4
5
6
7

最终的结果如下：

class 0:0.032182006265154946
class 1:0.0336352243495811
class 2:0.03491449856708539
class 3:0.033205199987016924
class 4:0.034989082254391006
class 5:0.0331936923801072
class 6:0.03519542406951625
class 7:0.14276183106876328（萌宠类最高）
class 8:0.035138968378985495
class 9:0.0320506177571864
class 10:0.034970413943529836
class 11:0.033309038283581525
class 12:0.033930527800123976
class 13:0.03278336996884944
class 14:0.035473397978207644
class 15:0.034846339484132204
class 16:0.0355179245862518
class 17:0.03428401522003527
class 18:0.03556253508239065
class 19:0.03555615701038051
class 20:0.03377058314903299
class 21:0.035026463749860785
class 22:0.03428401522003527
class 23:0.03418761030403304
class 24:0.03456346204880003
class 25:0.0346676010929670

详细的代码，我放置到github当中：
https://www.github.com/Quincy1994/SparkStudy/tree/master/NB_model/MYNaiveBayes.java