贝叶斯文本分类 java实现

　　昨天实现了一个基于贝叶斯定理的的文本分类，贝叶斯定理假设特征属性（在文本中就是词汇）对待分类项的影响都是独立的，道理比较简单，在中文分类系统中，分类的准确性与分词系统的好坏有很大的关系，这段代码也是试验不同分词系统才顺手写的一个。 

　　试验数据用的sogou实验室的文本分类样本，一共分为9个类别，每个类别文件夹下大约有2000篇文章。由于文本数据量确实较大，所以得想办法让每次训练的结果都能保存起来，以便于下次直接使用，我这里使用序列化的方式保存在硬盘。 

  训练代码如下：  

 

/**
 * 训练器
 * 
 * <a href="http://my.oschina.net/arthor" target="_blank" rel="nofollow">@author</a>  duyf
 * 
 */
class Train implements Serializable {

    /**
     * 
     */
    private static final long serialVersionUID = 1L;

    public final static String SERIALIZABLE_PATH = "D:\\workspace\\Test\\SogouC.mini\\Sample\\Train.ser";
    // 训练集的位置
    private String trainPath = "D:\\workspace\\Test\\SogouC.mini\\Sample";

    // 类别序号对应的实际名称
    private Map<String, String> classMap = new HashMap<String, String>();

    // 类别对应的txt文本数
    private Map<String, Integer> classP = new ConcurrentHashMap<String, Integer>();

    // 所有文本数
    private AtomicInteger actCount = new AtomicInteger(0);

    

    // 每个类别对应的词典和频数
    private Map<String, Map<String, Double>> classWordMap = new ConcurrentHashMap<String, Map<String, Double>>();

    // 分词器
    private transient Participle participle;

    private static Train trainInstance = new Train();

    public static Train getInstance() {
        trainInstance = new Train();

        // 读取序列化在硬盘的本类对象
        FileInputStream fis;
        try {
            File f = new File(SERIALIZABLE_PATH);
            if (f.length() != 0) {
                fis = new FileInputStream(SERIALIZABLE_PATH);
                ObjectInputStream oos = new ObjectInputStream(fis);
                trainInstance = (Train) oos.readObject();
                trainInstance.participle = new IkParticiple();
            } else {
                trainInstance = new Train();
            }
        } catch (Exception e) {
            e.printStackTrace();
        }

        return trainInstance;
    }

    private Train() {
        this.participle = new IkParticiple();
    }

    public String readtxt(String path) {
        BufferedReader br = null;
        StringBuilder str = null;
        try {
            br = new BufferedReader(new FileReader(path));

            str = new StringBuilder();

            String r = br.readLine();

            while (r != null) {
                str.append(r);
                r = br.readLine();

            }

            return str.toString();
        } catch (IOException ex) {
            ex.printStackTrace();
        } finally {
            if (br != null) {
                try {
                    br.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            str = null;
            br = null;
        }

        return "";
    }

    /**
     * 训练数据
     */
    public void realTrain() {
        // 初始化
        classMap = new HashMap<String, String>();
        classP = new HashMap<String, Integer>();
        actCount.set(0);
        classWordMap = new HashMap<String, Map<String, Double>>();

        // classMap.put("C000007", "汽车");
        classMap.put("C000008", "财经");
        classMap.put("C000010", "IT");
        classMap.put("C000013", "健康");
        classMap.put("C000014", "体育");
        classMap.put("C000016", "旅游");
        classMap.put("C000020", "教育");
        classMap.put("C000022", "招聘");
        classMap.put("C000023", "文化");
        classMap.put("C000024", "军事");

        // 计算各个类别的样本数
        Set<String> keySet = classMap.keySet();

        // 所有词汇的集合,是为了计算每个单词在多少篇文章中出现，用于后面计算df
        final Set<String> allWords = new HashSet<String>();

        // 存放每个类别的文件词汇内容
        final Map<String, List<String[]>> classContentMap = new ConcurrentHashMap<String, List<String[]>>();

        for (String classKey : keySet) {

            Participle participle = new IkParticiple();
            Map<String, Double> wordMap = new HashMap<String, Double>();
            File f = new File(trainPath + File.separator + classKey);
            File[] files = f.listFiles(new FileFilter() {

                @Override
                public boolean accept(File pathname) {
                    if (pathname.getName().endsWith(".txt")) {
                        return true;
                    }
                    return false;
                }

            });

            // 存储每个类别的文件词汇向量
            List<String[]> fileContent = new ArrayList<String[]>();
            if (files != null) {
                for (File txt : files) {
                    String content = readtxt(txt.getAbsolutePath());
                    // 分词
                    String[] word_arr = participle.participle(content, false);
                    fileContent.add(word_arr);
                    // 统计每个词出现的个数
                    for (String word : word_arr) {
                        if (wordMap.containsKey(word)) {
                            Double wordCount = wordMap.get(word);
                            wordMap.put(word, wordCount + 1);
                        } else {
                            wordMap.put(word, 1.0);
                        }
                        
                    }
                }
            }

            // 每个类别对应的词典和频数
            classWordMap.put(classKey, wordMap);

            // 每个类别的文章数目
            classP.put(classKey, files.length);
            actCount.addAndGet(files.length);
            classContentMap.put(classKey, fileContent);

        }

        

        

        // 把训练好的训练器对象序列化到本地 （空间换时间）
        FileOutputStream fos;
        try {
            fos = new FileOutputStream(SERIALIZABLE_PATH);
            ObjectOutputStream oos = new ObjectOutputStream(fos);
            oos.writeObject(this);
        } catch (Exception e) {
            e.printStackTrace();
        }

    }

    /**
     * 分类
     * 
     * @param text
     * <a href="http://my.oschina.net/u/556800" target="_blank" rel="nofollow">@return</a>  返回各个类别的概率大小
     */
    public Map<String, Double> classify(String text) {
        // 分词，并且去重
        String[] text_words = participle.participle(text, false);

        Map<String, Double> frequencyOfType = new HashMap<String, Double>();
        Set<String> keySet = classMap.keySet();
        for (String classKey : keySet) {
            double typeOfThis = 1.0;
            Map<String, Double> wordMap = classWordMap.get(classKey);
            for (String word : text_words) {
                Double wordCount = wordMap.get(word);
                int articleCount = classP.get(classKey);

                /*
                 * Double wordidf = idfMap.get(word); if(wordidf==null){
                 * wordidf=0.001; }else{ wordidf = Math.log(actCount / wordidf); }
                 */

                // 假如这个词在类别下的所有文章中木有，那么给定个极小的值 不影响计算
                double term_frequency = (wordCount == null) ? ((double) 1 / (articleCount + 1))
                        : (wordCount / articleCount);

                // 文本在类别的概率 在这里按照特征向量独立统计，即概率=词汇1/文章数 * 词汇2/文章数 。。。
                // 当double无限小的时候会归为0，为了避免 *10

                typeOfThis = typeOfThis * term_frequency * 10;
                typeOfThis = ((typeOfThis == 0.0) ? Double.MIN_VALUE
                        : typeOfThis);
                // System.out.println(typeOfThis+" : "+term_frequency+" :
                // "+actCount);
            }

            typeOfThis = ((typeOfThis == 1.0) ? 0.0 : typeOfThis);

            // 此类别文章出现的概率
            double classOfAll = classP.get(classKey) / actCount.doubleValue();

            // 根据贝叶斯公式 $(A|B)=S(B|A)*S(A)/S(B),由于$(B)是常数，在这里不做计算,不影响分类结果
            frequencyOfType.put(classKey, typeOfThis * classOfAll);
        }

        return frequencyOfType;
    }

    public void pringAll() {
        Set<Entry<String, Map<String, Double>>> classWordEntry = classWordMap
                .entrySet();
        for (Entry<String, Map<String, Double>> ent : classWordEntry) {
            System.out.println("类别： " + ent.getKey());
            Map<String, Double> wordMap = ent.getValue();
            Set<Entry<String, Double>> wordMapSet = wordMap.entrySet();
            for (Entry<String, Double> wordEnt : wordMapSet) {
                System.out.println(wordEnt.getKey() + ":" + wordEnt.getValue());
            }
        }
    }

    public Map<String, String> getClassMap() {
        return classMap;
    }

    public void setClassMap(Map<String, String> classMap) {
        this.classMap = classMap;
    }

}

 

 

 

 

　　在试验过程中，发觉某篇文章的分类不太准，某篇IT文章分到招聘类别下了，在仔细对比了训练数据后，发觉这是由于招聘类别每篇文章下面都带有“搜狗”的标志，而待分类的这篇IT文章里面充斥这搜狗这类词汇，结果招聘类下的概率比较大。由此想到，在除了做常规的贝叶斯计算时，需要把不同文本中出现次数多的词汇权重降低甚至删除（好比关键词搜索中的tf-idf），通俗点讲就是,在所有训练文本中某词汇（如的，地，得）出现的次数越多，这个词越不重要，比如IT文章中“软件”和“应用”这两个词汇，“应用”应该是很多文章类别下都有的，反而不太重要，但是“软件”这个词汇大多只出现在IT文章里，出现在大量文章的概率并不大。 我这里原本打算计算每个词的idf，然后给定一个阀值来判断是否需要纳入计算，但是由于词汇太多，计算量较大（等待结果时间较长），所以暂时注释掉了。 

 

 

来源：http://my.oschina.net/duyunfei/blog/80283