朴素贝叶斯算法&应用实例

最新推荐文章于 2024-05-23 15:43:21 发布

Keep-Up

最新推荐文章于 2024-05-23 15:43:21 发布

阅读量4.2k

点赞数

分类专栏：大数据文章标签：朴素贝叶斯机器学习大数据

本文链接：https://blog.csdn.net/qq_19470683/article/details/86633937

版权

大数据专栏收录该内容

9 篇文章 0 订阅

订阅专栏

朴素贝叶斯

朴素贝叶斯中的朴素是指假设各个特征之间相互独立，不会互相影响，所以称为朴素贝叶斯。正是因为这个假设，使得算法的模型简单且容易理解，虽然牺牲了一点准确性，但是如果模型训练的好，也能得到不错的分类效果。

朴素贝叶斯公式：
$P(y_i,X)=\frac{P(X,y_i)P(y_i)}{P(X)}=\frac{Py_i\prod P(x_i,y_i)}{P(X)}$
$P (X)$ 表示待分类自身的概率，其结果是一个常数，对结果不会造成影响，可忽略

$P(y_i)$ 表示每个类别的先验概率，即 $y_i$ 的概率

$P(y_i,X)$ 表示给定 $X$ 属于 $y_i$ 类别的概率

$P(X,y_i)$ 表示某个类别 $y_i$ 产生 $X$ 的概率

$P(x_i,y_i)$ 表示某个类别 $y_i$ 产生某个特征 $x_i$ 的概率

公式简单推导

下面我们简单看一下公式的推导过程

我们都已知条件概率公式（不懂的请先自行了解）
$P(A|B)=\frac{P(A,B)}{P(B)}$
然后可以得出 $P (A ∣ B) P (B) = P (A, B) = P (B ∣ A) P (A)$ ，然后我们带入条件概率公式得出 $P(A|B)=\frac{P(B|A)P(A)}{P(B)}$ 然后我们就可以看到它和朴素贝叶斯的前半部分的公式一样了。后边我们只需要推导 $P(X,y_i)=\prod P(x_i,y_i)$ 就可以了，后面的推导我们同个一个简单的例子来加以说明，更容易帮助你理解。因为后边的应用实例是对新闻的分类问题，所以我们这里也举一个简单的新闻分类的例子。

$科技，财经，体育，军事Y=\{科技，财经，体育，军事\}$ 假设现在新闻只有四个类别，用 $Y$ 表示， $y_i$ 表示其中某一类别，然后假设现在一共有一百篇新闻，并且已知他们各自的类别，科技类的40篇，财经类的30篇，体育类的20篇，军事类的10篇， $P(y_i)$ 表示某一类的先验概率，比如 $科技P(科技)=\frac{40}{100}=0.4$ ， $X=\{x_{i1},x_{i2} …x_{in}\}$ 表示某一篇文章， $x_i$ 表示该文章的某一个词（即某个事物的属性或者特征）， $P(X,y_i)$ 表示对于指定类别 $y_i$ 中出现 $X$ 的概率，这里有点不好理解，其实它就等于 $P(x_i,y_i)$ 对于指定类别 $y_i$ 中出现某个词 $x_i$ 的概率的乘积。比如「互联网」这个词在科技类的30篇文章中出现过，那么 $互联网科技P(互联网,科技)=\frac{30}{40}$ ，然后把文章中所有的词对类别的概率相乘就能得到 $P(X,y_i)$ ，当然前提就是我们前边说的那个假设，所有词（特征）之间是相互独立互不影响的。

评测指标

我们得出分类的结果后，怎么来评测我们训练的模型的好与不好呢？我们通常「准确度」「精确率」「召回率」这几个指标来进行判断模型的好坏。下边我们用一个简单的例子来说明这几个指标是怎么计算的。

下面我们看一个表。

/	/	预测类别	预测类别
/	/	科技(35)	财经(35)
实际类别	科技（40）	30	10
实际类别	财经（30）	5	25

表中表示实际上科技类的文章有 40 篇，财经类的有 30 篇，然而预测的结果科技类的有 35 篇，其中 30 篇预测正确了，有 5 篇预测错误了；预测结果财经类的有 35 篇，其中 25 篇预测正确了，10 篇预测错误了。

准确度

表示预测正确的文章数比上总的文章数：(30+25)/(40+30)=78%

精确率

表示每一类预测正确的数量比上预测的该类文章总数量，比如科技类精确率：30/(30+5)=85%

召回率

表示每一类预测正确的数量比上实际该类的总数量，比如科技类：30/40=75%

应用实例

上边我们已经了解了朴素贝叶斯公式及推导过程，下边我们来看一下在实际的新闻分类中的应用。

元数据的准备，我们的元数据是网上找来的一些各类的新闻，这里为了简单，我们只选取了科技、财经和体育三类数量不等的新闻，并且都已知他们的类别。然后通过中文结巴分词

对每篇新闻进行分词。这里我们用到的是gihub上的一个开源的python库，有兴趣的可以了解一下。

下面我们来看一下代码的具体实现。

首先我们先把汉字的文章转成每个词所对应的数字id的形式，方便我们后边的操作和计算。

Convert.py

import os
import sys
import random
import re

inputPath = sys.argv[1]
outputFile = sys.argv[2]
#训练集所占百分比
trainPercent = 0.8
wordDict = {}
wordList = []

trainOutputFile = open('%s.train' % outputFile, "w")
testOutputFile = open('%s.test' % outputFile, "w")

for fileName in os.listdir(inputPath):
    tag = 0
    if fileName.find('technology') != -1:
        tag = 1
    elif fileName.find('business') != -1:
        tag = 2
    elif fileName.find('sport') != -1:
        tag = 3

    outFile = trainOutputFile
    rd = random.random()
    if rd >= trainPercent:
        outFile = testOutputFile

    inputFile = open(inputPath+'/'+fileName, "r")
    content = inputFile.read().strip()
    content = content.decode('utf-8', 'ignore')
    content = content.replace('\n', ' ')
    r1 = u'[a-zA-Z0-9’!"#$%&\'()*+,-./:;<=>?@，。?★、…【】《》？“”‘’！[\\]^_`{|}~]+'
    content = re.sub(r1, '', content)
    outFile.write(str(tag)+' ')
    words = content.split(' ')
    for word in words:
        if word not in wordDict:
            wordList.append(word)
            wordDict[word] = len(wordList)

        outFile.write(str(wordDict[word]) + ' ')

    inputFile.close()

trainOutputFile.close()
testOutputFile.close()

朴素贝叶斯实现过程

NB.py

#Usage:
#Training: NB.py 1 TrainingDataFile ModelFile
#Testing: NB.py 0 TestDataFile ModelFile OutFile

import sys
import os
import math


DefaultFreq = 0.1
TrainingDataFile = "nb_data.train"
ModelFile = "nb_data.model"
TestDataFile = "nb_data.test"
TestOutFile = "nb_data.out"
ClassFeaDic = {}
ClassFreq = {}
WordDic = {}
ClassFeaProb = {}
ClassDefaultProb = {}
ClassProb = {}

#加载数据
def LoadData():
    i =0
    infile = open(TrainingDataFile, 'r')
    sline = infile.readline().strip()
    while len(sline) > 0:
        pos = sline.find("#")
        if pos > 0:
            sline = sline[:pos].strip()
        words = sline.split(' ')
        if len(words) < 1:
            print("Format error!")
            break
        classid = int(words[0])
        if classid not in ClassFeaDic:
            ClassFeaDic[classid] = {}
            ClassFeaProb[classid] = {}
            ClassFreq[classid]  = 0
        ClassFreq[classid] += 1
        words = words[1:]
        for word in words:
            if len(word) < 1:
                continue
            wid = int(word)
            if wid not in WordDic:
                WordDic[wid] = 1
            if wid not in ClassFeaDic[classid]:
                ClassFeaDic[classid][wid] = 1
            else:
                ClassFeaDic[classid][wid] += 1
        i += 1
        sline = infile.readline().strip()
    infile.close()
    print(i, "instances loaded!")
    print(len(ClassFreq), "classes!", len(WordDic), "words!")

#计算模型
def ComputeModel():
    sum = 0.0
    for freq in ClassFreq.values():
        sum += freq
    for classid in ClassFreq.keys():
        ClassProb[classid] = (float)(ClassFreq[classid])/(float)(sum)
    for classid in ClassFeaDic.keys():
        sum = 0.0
        for wid in ClassFeaDic[classid].keys():
            sum += ClassFeaDic[classid][wid]
        newsum = (float)(sum + 1)
        for wid in ClassFeaDic[classid].keys():
            ClassFeaProb[classid][wid] = (float)(ClassFeaDic[classid][wid]+DefaultFreq)/newsum
        ClassDefaultProb[classid] = (float)(DefaultFreq) / newsum
    return

#保存模型
def SaveModel():
    outfile = open(ModelFile, 'w')
    for classid in ClassFreq.keys():
        outfile.write(str(classid))
        outfile.write(' ')
        outfile.write(str(ClassProb[classid]))
        outfile.write(' ')
        outfile.write(str(ClassDefaultProb[classid]))
        outfile.write(' ' )
    outfile.write('\n')
    for classid in ClassFeaDic.keys():
        for wid in ClassFeaDic[classid].keys():
            outfile.write(str(wid)+' '+str(ClassFeaProb[classid][wid]))
            outfile.write(' ')
        outfile.write('\n')
    outfile.close()

#加载模型
def LoadModel():
    global WordDic
    WordDic = {}
    global ClassFeaProb
    ClassFeaProb = {}
    global ClassDefaultProb
    ClassDefaultProb = {}
    global ClassProb
    ClassProb = {}
    infile = open(ModelFile, 'r')
    sline = infile.readline().strip()
    items = sline.split(' ')
    if len(items) < 6:
        print("Model format error!")
        return
    i = 0
    while i < len(items):
        classid = int(items[i])
        ClassFeaProb[classid] = {}
        i += 1
        if i >= len(items):
            print("Model format error!")
            return
        ClassProb[classid] = float(items[i])
        i += 1
        if i >= len(items):
            print("Model format error!")
            return
        ClassDefaultProb[classid] = float(items[i])
        i += 1
    for classid in ClassProb.keys():
        sline = infile.readline().strip()
        items = sline.split(' ')
        i = 0
        while i < len(items):
            wid  = int(items[i])
            if wid not in WordDic:
                WordDic[wid] = 1
            i += 1
            if i >= len(items):
                print("Model format error!")
                return
            ClassFeaProb[classid][wid] = float(items[i])
            i += 1
    infile.close()
    print(len(ClassProb), "classes!", len(WordDic), "words!")

#预测类别
def Predict():
    global WordDic
    global ClassFeaProb
    global ClassDefaultProb
    global ClassProb

    TrueLabelList = []
    PredLabelList = []
    i =0
    infile = open(TestDataFile, 'r')
    outfile = open(TestOutFile, 'w')
    sline = infile.readline().strip()
    scoreDic = {}
    iline = 0
    while len(sline) > 0:
        iline += 1
        if iline % 10 == 0:
            print(iline," lines finished!\r")
        pos = sline.find("#")
        if pos > 0:
            sline = sline[:pos].strip()
        words = sline.split(' ')
        if len(words) < 1:
            print("Format error!")
            break
        classid = int(words[0])
        TrueLabelList.append(classid)
        words = words[1:]
        for classid in ClassProb.keys():
            scoreDic[classid] = math.log(ClassProb[classid])
        for word in words:
            if len(word) < 1:
                continue
            wid = int(word)
            if wid not in WordDic:
                continue
            for classid in ClassProb.keys():
                if wid not in ClassFeaProb[classid]:
                    scoreDic[classid] += math.log(ClassDefaultProb[classid])
                else:
                    scoreDic[classid] += math.log(ClassFeaProb[classid][wid])
        i += 1
        maxProb = max(scoreDic.values())
        for classid in scoreDic.keys():
            if scoreDic[classid] == maxProb:
                PredLabelList.append(classid)
        sline = infile.readline().strip()
    infile.close()
    outfile.close()
    print(len(PredLabelList),len(TrueLabelList))
    return TrueLabelList,PredLabelList

#计算准确度
def Evaluate(TrueList, PredList):
    accuracy = 0
    i = 0
    while i < len(TrueList):
        if TrueList[i] == PredList[i]:
            accuracy += 1
        i += 1
    accuracy = (float)(accuracy)/(float)(len(TrueList))
    print("Accuracy:",accuracy)

#计算精确率和召回率
def CalPreRec(TrueList,PredList,classid):
    correctNum = 0
    allNum = 0
    predNum = 0
    i = 0
    while i < len(TrueList):
        if TrueList[i] == classid:
            allNum += 1
            if PredList[i] == TrueList[i]:
                correctNum += 1
        if PredList[i] == classid:
            predNum += 1
        i += 1
    return (float)(correctNum)/(float)(predNum),(float)(correctNum)/(float)(allNum)

#main framework
if sys.argv[1] == '1':
    print("start training:")
    LoadData()
    ComputeModel()
    SaveModel()
elif sys.argv[1] == '0':
    print("start testing:")

    LoadModel()
    TList,PList = Predict()
    i = 0
    outfile = open(TestOutFile, 'w')
    while i < len(TList):
        outfile.write(str(TList[i]))
        outfile.write(' ')
        outfile.write(str(PList[i]))
        outfile.write('\n')
        i += 1
    outfile.close()
    Evaluate(TList,PList)
    for classid in ClassProb.keys():
        pre,rec = CalPreRec(TList, PList,classid)
        print("Precision and recall for Class",classid,":",pre,rec)
else:
    print("Usage incorrect!")

欢迎关注公众号：「努力给自己看」

公众号200x200

Keep-Up

关注

0
点赞
踩
16

收藏

觉得还不错? 一键收藏
0
评论
朴素贝叶斯算法&应用实例

朴素贝叶斯朴素贝叶斯中的朴素是指假设各个特征之间相互独立，不会互相影响，所以称为朴素贝叶斯。正是因为这个假设，使得算法的模型简单且容易理解，虽然牺牲了一点准确性，但是如果模型训练的好，也能得到不错的分类效果。朴素贝叶斯公式：P(yi,X)=P(X,yi)P(yi)P(X)=Pyi∏P(xi,yi)P(X)P(y_i,X)=\frac{P(X,y_i)P(y_i)}{P(X)}=\frac{...
复制链接

扫一扫