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

一细办、簡(jiǎn)介

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

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

• 項(xiàng)目使用JDK8

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

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

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

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

• 我們把P(A)稱(chēng)為"先驗(yàn)概率"（Prior probability）巷懈，即在B事件發(fā)生之前该抒，我們對(duì)A事件概率的一個(gè)判斷。P(A|B)稱(chēng)為"后驗(yàn)概率"（Posterior probability）砸喻，即在B事件發(fā)生之后柔逼，我們對(duì)A事件概率的重新評(píng)估。P(B|A)/P(B)稱(chēng)為"可能性函數(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事件無(wú)助于判斷事件A的可能性结胀；如果"可能性函數(shù)"<1赞咙，意味著"先驗(yàn)概率"被削弱，事件A的可能性變小糟港。

二攀操、例子

• 別墅和狗
  一座別墅在過(guò)去的 20 年里一共發(fā)生過(guò) 2 次被盜，別墅的主人有一條狗秸抚，狗平均每周晚上叫 3 次速和，在盜賊入侵時(shí)狗叫的概率被估計(jì)為 0.9歹垫，問(wèn)題是：在狗叫的時(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)
火影忍者 自來(lái)
火影忍者 火影忍者
火影忍者 仙人
火影忍者 六道
火影忍者 大戰(zhàn)
火影忍者 九尾
火影忍者 忍者
火影忍者 究極
火影忍者 綱手
火影忍者 鳴人
火影忍者 木葉
火影忍者 忍術(shù)
火影忍者 穢土
火影忍者 宇智波
火影忍者 九尾妖狐
火影忍者 阿飛
海賊王 正文
海賊王 尾田
海賊王 海賊王
海賊王 弗蘭奇
海賊王 草帽
海賊王 海賊
海賊王 武海
海賊王 事件
海賊王 懸賞
海賊王 第話
海賊王 夢(mèng)想
海賊王 血型
海賊王 王下
海賊王 航路
海賊王 歷史
海賊王 德雷斯
海賊王 船長(zhǎng)
海賊王 惡魔
海賊王 路飛
海賊王 漫畫(huà)
海賊王 超新星
海賊王 羅薩篇
海賊王 世界
海賊王 果實(shí)
海賊王 冥王
海賊王 榮一郎
海賊王 海賊團(tuán)
海賊王 司法
海賊王 超人
海賊王 成為
海賊王 尋找
海賊王 傳說(shuō)
海賊王 海賊王
海賊王 中海
海賊王 羅杰
海賊王 秘寶
海賊王 留下
海賊王 伙伴
海賊王 ONE
海賊王 PIECE
海賊王 海賊
海賊王 志同道合
海賊王 揚(yáng)起
海賊王 實(shí)現(xiàn)
龍珠 復(fù)活
龍珠 仙人
龍珠 武道
龍珠 得到
龍珠 軍團(tuán)
龍珠 找尋
龍珠 魔王
龍珠 餃子
龍珠 特典
龍珠 打敗
龍珠 花梨
龍珠 緞帶
龍珠 發(fā)售日期
龍珠 龍珠
龍珠 天津
龍珠 七龍珠
龍珠 比克
龍珠 天神
龍珠 修練
龍珠 悟空
龍珠 封入
龍珠 次郎
龍珠 拉夫
龍珠 封印
龍珠 許愿
龍珠 兵衛(wèi)
龍珠 一武道
龍珠 動(dòng)畫(huà)

• 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ì)算器主體類(lèi)
 */
public class Bayes {

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

    /**
     * 將原訓(xùn)練元組按類(lèi)別劃分
     * 
     * @param datas
     *            訓(xùn)練元組
     * @return Map<類(lèi)別痒留，屬于該類(lèi)別的訓(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è)試元組的類(lèi)別
     * 
     * @param datas
     *            訓(xùn)練元組
     * @param testData
     *            測(cè)試元組
     * @return 測(cè)試元組的類(lèi)別
     */
    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è)試元組的類(lèi)別
     * 
     * @param testData
     *            測(cè)試元組
     * @return 測(cè)試元組的類(lèi)別
     * @throws Exception
     */
    public String predictClassify(ArrayList<String> testData, String mId) throws Exception {
        return predictClassify(read(mId), testData);
    }

    /**
     * 某一特征值在某一分類(lèi)上的概率分布[ P(key|Classify) ]
     * 
     * @param classify
     *            某一分類(lèi)特征向量集
     * @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; // 分類(lèi)中的某一特征向量
        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;
    }

    /**
     * 獲得某一分類(lèi)的概率 [ P(Classify) ]
     * 
     * @param classes
     *            分類(lèi)集合
     * @param classify
     *            某一特定分類(lèi)
     * @return 某一分類(lèi)的概率
     */
    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
     *            所有分類(lèi)的數(shù)據(jù)集
     * @param key
     *            某一特征值
     * @return 某一特征值在所有分類(lèi)數(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; // 分類(lèi)中的某一特征向量
            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的情況下谴麦，是分類(lèi)classify的概率 [ P(Classify | key) ]
     * 
     * @param map
     *            所有分類(lèi)的數(shù)據(jù)集
     * @param classify
     *            某一特定分類(lèi)
     * @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分類(lèi)：" + classification);
                total++;
            }
            reader.close();
            long end = System.currentTimeMillis();
            System.out.println("正確分類(lèi)：" + 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í)代”，為了尋找傳說(shuō)中海賊王羅杰所留下的大秘寶“ONE PIECE”伸头，無(wú)數(shù)海賊揚(yáng)起旗幟匾效，互相爭(zhēng)斗。有一個(gè)夢(mèng)想成為海盜的少年叫路飛恤磷，他因誤食“惡魔果實(shí)”而成為了橡皮人面哼，在獲得超人能力的同時(shí)付出了一輩子無(wú)法游泳的代價(jià)。十年后扫步，路飛為實(shí)現(xiàn)與因救他而斷臂的香克斯的約定而出海魔策，他在旅途中不斷尋找志同道合的伙伴，開(kāi)始了以成為海賊王為目標(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ì)文章