github項(xiàng)目地址：https://github.com/liangzhicheng120/bayes

一、簡介

• 項(xiàng)目使用SpringBoot做了一層web封裝

• 項(xiàng)目使用的分詞工具hanlp

• 項(xiàng)目使用JDK8

• 貝葉斯法則
  事件A在事件B(發(fā)生)的條件下的概率，與事件B在事件A的條件下的概率是不一樣的；然而，這兩者是有確定的關(guān)系,貝葉斯法則就是這種關(guān)系的陳述。

• 貝葉斯術(shù)語
  [圖片上傳失敗...(image-d286a7-1547375244426)]
  其中L(A|B)是在B發(fā)生的情況下A發(fā)生的可能性。
  在貝葉斯法則中，每個(gè)名詞都有約定俗成的名稱：
  Pr(A)是A的先驗(yàn)概率或邊緣概率。之所以稱為"先驗(yàn)"是因?yàn)樗豢紤]任何B方面的因素。
  Pr(A|B)是已知B發(fā)生后A的條件概率，也由于得自B的取值而被稱作A的后驗(yàn)概率。
  Pr(B|A)是已知A發(fā)生后B的條件概率，也由于得自A的取值而被稱作B的后驗(yàn)概率。
  Pr(B)是B的先驗(yàn)概率或邊緣概率，也作標(biāo)準(zhǔn)化常量（normalized constant）。
  后驗(yàn)概率 = (似然度 * 先驗(yàn)概率)/標(biāo)準(zhǔn)化常量 也就是說，后驗(yàn)概率與先驗(yàn)概率和似然度的乘積成正比。

• 貝葉斯推斷的含義
  對(duì)條件概率公式進(jìn)行變形，可以得到如下形式：

[圖片上傳失敗...(image-3fbd35-1547375244427)]

• 我們把P(A)稱為"先驗(yàn)概率"（Prior probability），即在B事件發(fā)生之前，我們對(duì)A事件概率的一個(gè)判斷。P(A|B)稱為"后驗(yàn)概率"（Posterior probability），即在B事件發(fā)生之后，我們對(duì)A事件概率的重新評(píng)估。P(B|A)/P(B)稱為"可能性函數(shù)"（Likelyhood），這是一個(gè)調(diào)整因子，使得預(yù)估概率更接近真實(shí)概率。
  后驗(yàn)概率?。健∠闰?yàn)概率 ｘ 調(diào)整因子

• 這就是貝葉斯推斷的含義。我們先預(yù)估一個(gè)"先驗(yàn)概率"，然后加入實(shí)驗(yàn)結(jié)果，看這個(gè)實(shí)驗(yàn)到底是增強(qiáng)還是削弱了"先驗(yàn)概率"，由此得到更接近事實(shí)的"后驗(yàn)概率"。
  在這里，如果"可能性函數(shù)"P(B|A)/P(B)>1，意味著"先驗(yàn)概率"被增強(qiáng)，事件A的發(fā)生的可能性變大；如果"可能性函數(shù)"=1，意味著B事件無助于判斷事件A的可能性；如果"可能性函數(shù)"<1，意味著"先驗(yàn)概率"被削弱，事件A的可能性變小。

二、例子

• 別墅和狗
  一座別墅在過去的 20 年里一共發(fā)生過 2 次被盜，別墅的主人有一條狗，狗平均每周晚上叫 3 次，在盜賊入侵時(shí)狗叫的概率被估計(jì)為 0.9，問題是：在狗叫的時(shí)候發(fā)生入侵的概率是多少？
  我們假設(shè) A 事件為狗在晚上叫，B 為盜賊入侵，則P(A) = 3 / 7，P(B)=2/(20·365)=2/7300，P(A | B) = 0.9，按照公式很容易得出結(jié)果：P(B|A)=0.9*(2/7300)/(3/7)=0.00058

三、實(shí)戰(zhàn)代碼

• 模型文件（classify.txt）

火影忍者 火影
火影忍者 秘傳
火影忍者 大蛇丸
火影忍者 劇場(chǎng)版
火影忍者 動(dòng)作
火影忍者 激斗
火影忍者 戰(zhàn)斗
火影忍者 轉(zhuǎn)生
火影忍者 佐助
火影忍者 村子
火影忍者 第六代火影
火影忍者 克拉
火影忍者 卡卡
火影忍者 帶土
火影忍者 疾風(fēng)
火影忍者 自來
火影忍者 火影忍者
火影忍者 仙人
火影忍者 六道
火影忍者 大戰(zhàn)
火影忍者 九尾
火影忍者 忍者
火影忍者 究極
火影忍者 綱手
火影忍者 鳴人
火影忍者 木葉
火影忍者 忍術(shù)
火影忍者 穢土
火影忍者 宇智波
火影忍者 九尾妖狐
火影忍者 阿飛
海賊王 正文
海賊王 尾田
海賊王 海賊王
海賊王 弗蘭奇
海賊王 草帽
海賊王 海賊
海賊王 武海
海賊王 事件
海賊王 懸賞
海賊王 第話
海賊王 夢(mèng)想
海賊王 血型
海賊王 王下
海賊王 航路
海賊王 歷史
海賊王 德雷斯
海賊王 船長
海賊王 惡魔
海賊王 路飛
海賊王 漫畫
海賊王 超新星
海賊王 羅薩篇
海賊王 世界
海賊王 果實(shí)
海賊王 冥王
海賊王 榮一郎
海賊王 海賊團(tuán)
海賊王 司法
海賊王 超人
海賊王 成為
海賊王 尋找
海賊王 傳說
海賊王 海賊王
海賊王 中海
海賊王 羅杰
海賊王 秘寶
海賊王 留下
海賊王 伙伴
海賊王 ONE
海賊王 PIECE
海賊王 海賊
海賊王 志同道合
海賊王 揚(yáng)起
海賊王 實(shí)現(xiàn)
龍珠 復(fù)活
龍珠 仙人
龍珠 武道
龍珠 得到
龍珠 軍團(tuán)
龍珠 找尋
龍珠 魔王
龍珠 餃子
龍珠 特典
龍珠 打敗
龍珠 花梨
龍珠 緞帶
龍珠 發(fā)售日期
龍珠 龍珠
龍珠 天津
龍珠 七龍珠
龍珠 比克
龍珠 天神
龍珠 修練
龍珠 悟空
龍珠 封入
龍珠 次郎
龍珠 拉夫
龍珠 封印
龍珠 許愿
龍珠 兵衛(wèi)
龍珠 一武道
龍珠 動(dòng)畫

• TestBayes.java

package com.xinrui.util;

import java.io.BufferedReader;
import java.io.File;
import java.io.FileReader;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import org.apache.commons.io.Charsets;
import org.apache.commons.io.FileUtils;
import org.apache.commons.lang.StringUtils;
import org.apache.log4j.Logger;

import com.hankcs.hanlp.HanLP;

/**
 * 貝葉斯計(jì)算器主體類
 */
public class Bayes {

    private static Logger logger = Logger.getLogger(Bayes.class);

    /**
     * 將原訓(xùn)練元組按類別劃分
     * 
     * @param datas
     *            訓(xùn)練元組
     * @return Map<類別，屬于該類別的訓(xùn)練元組>
     */
    public static Map<String, ArrayList<ArrayList<String>>> classifyByCategory(ArrayList<ArrayList<String>> datas) {
        if (datas == null) {
            return null;
        }

        Map<String, ArrayList<ArrayList<String>>> map = new HashMap<String, ArrayList<ArrayList<String>>>();
        ArrayList<String> singleTrainning = null;
        String classificaion = "";
        for (int i = 0; i < datas.size(); i++) {
            singleTrainning = datas.get(i);
            classificaion = singleTrainning.get(0);
            singleTrainning.remove(0);
            if (map.containsKey(classificaion)) {
                map.get(classificaion).add(singleTrainning);
            } else {
                ArrayList<ArrayList<String>> list = new ArrayList<ArrayList<String>>();
                list.add(singleTrainning);
                map.put(classificaion, list);
            }
        }

        return map;
    }

    /**
     * 在訓(xùn)練數(shù)據(jù)的基礎(chǔ)上預(yù)測(cè)測(cè)試元組的類別
     * 
     * @param datas
     *            訓(xùn)練元組
     * @param testData
     *            測(cè)試元組
     * @return 測(cè)試元組的類別
     */
    public static String predictClassify(ArrayList<ArrayList<String>> datas, ArrayList<String> testData) {

        if (datas == null || testData == null) {
            return null;
        }

        int maxPIndex = -1;
        Map<String, ArrayList<ArrayList<String>>> map = classifyByCategory(datas);
        Object[] classes = map.keySet().toArray();
        double maxProbability = 0.0;
        for (int i = 0; i < map.size(); i++) {
            double p = 0.0;
            for (int j = 0; j < testData.size(); j++) {
                p += calProbabilityClassificationInKey(map, classes[i].toString(), testData.get(j));
            }
            if (p > maxProbability) {
                maxProbability = p;
                maxPIndex = i;
            }
        }

        return maxPIndex == -1 ? "其他" : classes[maxPIndex].toString();
    }

    /**
     * 在訓(xùn)練數(shù)據(jù)的基礎(chǔ)上預(yù)測(cè)測(cè)試元組的類別
     * 
     * @param testData
     *            測(cè)試元組
     * @return 測(cè)試元組的類別
     * @throws Exception
     */
    public String predictClassify(ArrayList<String> testData, String mId) throws Exception {
        return predictClassify(read(mId), testData);
    }

    /**
     * 某一特征值在某一分類上的概率分布[ P(key|Classify) ]
     * 
     * @param classify
     *            某一分類特征向量集
     * @param value
     *            某一特征值
     * @return 概率分布
     */
    private static double calProbabilityKeyInClassification(ArrayList<ArrayList<String>> classify, String value) {
        if (classify == null || StringUtils.isEmpty(value)) {
            return 0.0;
        }
        int totleKeyCount = 0;
        int foundKeyCount = 0;
        ArrayList<String> featureVector = null; // 分類中的某一特征向量
        for (int i = 0; i < classify.size(); i++) {
            featureVector = classify.get(i);
            for (int j = 0; j < featureVector.size(); j++) {
                totleKeyCount++;
                if (featureVector.get(j).equalsIgnoreCase(value)) {
                    foundKeyCount++;
                }
            }
        }
        return totleKeyCount == 0 ? 0.0 : 1.0 * foundKeyCount / totleKeyCount;
    }

    /**
     * 獲得某一分類的概率 [ P(Classify) ]
     * 
     * @param classes
     *            分類集合
     * @param classify
     *            某一特定分類
     * @return 某一分類的概率
     */
    private static double calProbabilityClassification(Map<String, ArrayList<ArrayList<String>>> map, String classify) {
        if (map == null | StringUtils.isEmpty(classify)) {
            return 0;
        }
        Object[] classes = map.keySet().toArray();
        int totleClassifyCount = 0;
        for (int i = 0; i < classes.length; i++) {
            totleClassifyCount += map.get(classes[i].toString()).size();
        }
        return 1.0 * map.get(classify).size() / totleClassifyCount;
    }

    /**
     * 獲得關(guān)鍵詞的總概率
     * 
     * @param map
     *            所有分類的數(shù)據(jù)集
     * @param key
     *            某一特征值
     * @return 某一特征值在所有分類數(shù)據(jù)集中的比率
     */
    private static double calProbabilityKey(Map<String, ArrayList<ArrayList<String>>> map, String key) {
        if (map == null || StringUtils.isEmpty(key)) {
            return 0;
        }
        int foundKeyCount = 0;
        int totleKeyCount = 0;
        Object[] classes = map.keySet().toArray();
        for (int i = 0; i < map.size(); i++) {
            ArrayList<ArrayList<String>> classify = map.get(classes[i]);
            ArrayList<String> featureVector = null; // 分類中的某一特征向量
            for (int j = 0; j < classify.size(); j++) {
                featureVector = classify.get(j);
                for (int k = 0; k < featureVector.size(); k++) {
                    totleKeyCount++;
                    if (featureVector.get(k).equalsIgnoreCase(key)) {
                        foundKeyCount++;
                    }
                }
            }
        }
        return totleKeyCount == 0 ? 0.0 : 1.0 * foundKeyCount / totleKeyCount;
    }

    /**
     * 計(jì)算在出現(xiàn)key的情況下，是分類classify的概率 [ P(Classify | key) ]
     * 
     * @param map
     *            所有分類的數(shù)據(jù)集
     * @param classify
     *            某一特定分類
     * @param key
     *            某一特定特征
     * @return P(Classify | key)
     */
    private static double calProbabilityClassificationInKey(Map<String, ArrayList<ArrayList<String>>> map, String classify, String key) {
        ArrayList<ArrayList<String>> classifyList = map.get(classify);
        double pkc = calProbabilityKeyInClassification(classifyList, key); // p(key|classify)
        double pc = calProbabilityClassification(map, classify); // p(classify)
        double pk = calProbabilityKey(map, key); // p(key)
        return pk == 0 ? 0 : pkc * pc / pk; // p(classify | key)
    }

    /**
     * 讀取訓(xùn)練文檔中的訓(xùn)練數(shù)據(jù) 并進(jìn)行封裝
     * 
     * @param filePath
     *            訓(xùn)練文檔的路徑
     * @return 訓(xùn)練數(shù)據(jù)集
     * @throws Exception
     */
    public static ArrayList<ArrayList<String>> read(String clzss) throws Exception {
        ArrayList<String> singleTrainning = null;
        ArrayList<ArrayList<String>> trainningSet = new ArrayList<ArrayList<String>>();
        List<String> datas = new ArrayList<String>(FileUtils.readLines(new File(clzss), Charsets.UTF_8));
        if (datas.size() == 0) {
            logger.error("[" + "模型文件加載錯(cuò)誤" + "]" + clzss);
            throw new Exception("模型文件加載錯(cuò)誤!");
        }
        for (int i = 0; i < datas.size(); i++) {
            String[] characteristicValues = datas.get(i).split(" ");
            singleTrainning = new ArrayList<String>();
            for (int j = 0; j < characteristicValues.length; j++) {
                if (StringUtils.isNotEmpty(characteristicValues[j])) {
                    singleTrainning.add(characteristicValues[j]);
                }
            }
            trainningSet.add(singleTrainning);
        }
        return trainningSet;
    }

    /**
     * 
     * @param fileName
     *            訓(xùn)練文件
     * @param size
     *            關(guān)鍵詞個(gè)數(shù)
     */
    public static void trainBayes(String fileName, String mId, int size) {
        try {
            Bayes bayes = new Bayes();
            BufferedReader reader = new BufferedReader(new FileReader(fileName));
            String line = null;
            int total = 0;
            int right = 0;
            long start = System.currentTimeMillis();
            while ((line = reader.readLine()) != null) {
                ArrayList<String> testData = (ArrayList<String>) HanLP.extractKeyword(line, size);
                String classification = bayes.predictClassify(testData, mId);
                if (classification.equals(fileName.split("\\.")[0])) {
                    right += 1;
                }
                System.out.print("\n分類：" + classification);
                total++;
            }
            reader.close();
            long end = System.currentTimeMillis();
            System.out.println("正確分類：" + right);
            System.out.println("總行數(shù)：" + total);
            System.out.println("正確率：" + MathUtil.div(right, total, 4) * 100 + "%");
            System.out.println("程序運(yùn)行時(shí)間： " + (end - start) / 1000 + "s");
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

}

• TestBayes.java

package com.xinrui.test;

import java.util.ArrayList;

import com.hankcs.hanlp.HanLP;
import com.xinrui.util.Bayes;

public class TestBayes {
    public static void main(String[] args) throws Exception {
        // 獲取當(dāng)前工程存放位置
        String path = TestBayes.class.getResource("").getPath();
        String classPath = path.substring(0, path.indexOf("/com/xinrui"));
        // 模型文件存放位置
        String modelName = classPath + "/model/classify_model.txt";
        ArrayList<ArrayList<String>> model = Bayes.read(modelName);
        // 抽取10個(gè)關(guān)鍵詞組成一個(gè)元祖
        ArrayList<String> testData = (ArrayList<String>) HanLP
                .extractKeyword(
                        "時(shí)值“大海賊時(shí)代”，為了尋找傳說中海賊王羅杰所留下的大秘寶“ONE PIECE”，無數(shù)海賊揚(yáng)起旗幟，互相爭斗。有一個(gè)夢(mèng)想成為海盜的少年叫路飛，他因誤食“惡魔果實(shí)”而成為了橡皮人，在獲得超人能力的同時(shí)付出了一輩子無法游泳的代價(jià)。十年后，路飛為實(shí)現(xiàn)與因救他而斷臂的香克斯的約定而出海，他在旅途中不斷尋找志同道合的伙伴，開始了以成為海賊王為目標(biāo)的偉大的冒險(xiǎn)旅程[9]  ",
                        15);
        // 輸出預(yù)測(cè)結(jié)果
        System.out.println(Bayes.predictClassify(model, testData));
    }
}

• 結(jié)果

  
  
  image

關(guān)注我的技術(shù)公眾號(hào)《漫談人工智能》，每天推送優(yōu)質(zhì)文章