《机器学习实战》（三）---朴素贝叶斯

最新推荐文章于 2024-07-10 16:47:58 发布

really_not_Yanzu

最新推荐文章于 2024-07-10 16:47:58 发布

阅读量348

点赞数

分类专栏：机器学习实战文章标签：算法 python 机器学习

本文链接：https://blog.csdn.net/really_not_Yanzu/article/details/105949735

版权

机器学习实战专栏收录该内容

5 篇文章 1 订阅

订阅专栏

朴素贝叶斯

贝叶斯引入

前两章分别介绍了K-近邻算法和决策树，现在有这样一个数据集，他由两类数据构成，数据分布如图，现有一个新的数据点（x,y）,如何简单快捷的将其分类成三角形/圆形？
K近邻算法肯定可以算出来，但是为了这么一个小小的点计算量未免过大，决策树在这里好像就不是那么适用了。我们有一个非常自然的想法，能不能计算出这个点是三角形的概率p1(x,y），是圆形的概率p2(x,y)，比较p1和p2，更大的那个就应该是分类的结果，这就是贝叶斯决策理论。
在这里插入图片描述

贝叶斯公式的理解

在这里插入图片描述

上面这个公式就是贝叶斯公式，初学者一看到这个公式肯定会一脸懵，我尽量把自己的理解写出来。
朴素贝叶斯的就是对条件独立性做了假设，即各个条件相互独立，互不影响，因此有

将公式4.3带入到公式4.4，有
在这里插入图片描述
计算出每个ck的概率，这个数据就应该被划分到概率最大的那个ck类，对于每一个ck而言，分母都是一样的，所以可以将其忽略，我们的目的就是要求到底哪个ck能对应最大的分子值。即

这公式就是最大后验概率估计，他和最大似然估计非常像，主要的区别就是多了一个P(Y=ck)(先验概率)，我们考虑先把前验概率拿出来，单看最大似然估计，这是符合我们逻辑思考的，计算每一类ck的条件概率，选其中最大的那个。
贝叶斯的思想就是要考虑以往经验分析得到的概率，即先验概率。即便我们有一些证据，但是我们能多么相信他们，扔10次硬币，有7次正面朝上，我们能说扔一枚硬币正面朝上的概率是70%吗？，不能，因为凭借我们的经验，我们知道概率是50%，这个50%就是先验概率，是在扔硬币之前我们就已经知道的事情。这十次抛硬币是一个证据，可能比较靠谱也可能没那么靠谱，贝叶斯的想法是我们能多么相信这个证据？我们要在这个证据的基础上加上自己的判断进行修正，即最大似然估计乘上先验概率，这就是最大后验概率的思想。随着抛掷的次数增多，前验概率的影响越来越小，最终概率会向着最大似然估计的结果靠近。

example_屏蔽侮辱性言论

# version:python3.7.3
# author:hty
# date:2020.5.3

from numpy import *
import re
import os

# 加载数据
def loadDataSet():
    postingList = [['my', 'dog', 'has', 'flea', 'problems', 'help', 'please'],
                 ['maybe', 'not', 'take', 'him', 'to', 'dog', 'park', 'stupid'],
                 ['my', 'dalmation', 'is', 'so', 'cute', 'I', 'love', 'him'],
                 ['stop', 'posting', 'stupid', 'worthless', 'garbage'],
                 ['mr', 'licks', 'ate', 'my', 'steak', 'how', 'to', 'stop', 'him'],
                 ['quit', 'buying', 'worthless', 'dog', 'food', 'stupid']]
    # 1代表有辱骂单词
    classVec = [0, 1, 0, 1, 0, 1]
    return postingList, classVec

def createVocabList(dataSet):
	'''
	function：创建一个包含数据集中所有单词的list
	'''
    vocabSet = set([])
    for document in dataSet:
        vocabSet = vocabSet | set(document)
    return list(vocabSet)

def setOfWords2Vec(vocabList, inputSet):
	'''
	function:将输入文档各个单子转化为向量，0表示不存在，1表示存在
	'''
    returnVec = [0]*len(vocabList)
    for word in inputSet:
        if word in vocabList:
            returnVec[vocabList.index(word)] = 1
        else:
            print("the word: %s is not in my Vocabulary!" % word)
    return returnVec

def trainNB0(trainMatrix, trainCategory):
	'''
	function:朴素贝叶斯分类训练函数
	Parameters：利用setOfWords2Vec函数将数据集所有文本信息转化为0/1数字，形成的文档矩阵；每篇文档是否为侮辱性文档的向量
	return:
		p0Vect:类别0所有文档中各个词条出现的频数p(wi|c0)
		p1Vect:类别1所有文档中各个词条出现的频数p(wi|c1)
		pAbusive:p(c1)
	'''
	# 有几篇文档
    numTrainDocs = len(trainMatrix)
    # 数据集一共有多少单词
    numWords = len(trainMatrix[0])
    # 含有侮辱性单词的文档/总文档数，贝叶斯公式中的p(c1)
    pAbusive = sum(trainCategory)/float(numTrainDocs)
    # p0Num，p0Num是用于计算p0Vec，p1Vec的分子
    p0Num = ones(numWords); p1Num = ones(numWords) # 本来是zeros，计算p(w1|c1)*p(w2|c1)*p(w3|c1)···，为削弱概率为0时带来的影响，所以换为1。
    # 这两个是用以计算的分母
    p0Denom = 2.0; p1Denom = 2.0                    
    for i in range(numTrainDocs):
    	# 如果是c1类别
        if trainCategory[i] == 1:
        	# 这个文本包含的单词，在p1Num中全部+1，统计各个c1中各个单词出现的次数
            p1Num += trainMatrix[i]
            # 统计c1中出现的单词总数
            p1Denom += sum(trainMatrix[i])
            #print('p1Denom', p1Denom)
        else:
        	# 同上
            p0Num += trainMatrix[i]
            p0Denom += sum(trainMatrix[i])
    # p1Vect，p0Vect分别代表着类别1所有文档中各个词条出现的频数p(wi|c1)，类别0所有文档中各个词条出现的频数p(wi|c0)，这是两个向量。
    # 本来是没有log，考虑到后面有许多很小的数要连乘，可能会四舍五入为0，为削弱这种影响，取log
    # p1Vect，p0Vect是原本的p(wi|c0)，p(wi|c1)取Log！！！
  	p1Vect = log(p1Num/p1Denom)  
    p0Vect = log(p0Num/p0Denom) 
    return p0Vect, p1Vect, pAbusive

def classifyNB(vec2Classify, p0Vec, p1Vec, pClass1):
	'''
	function:判断类别
	Parameters：
		vec2Classify：待判断的文本向量
	'''
	# 实际上计算的是贝叶斯公式的分子部分，因为分母部分都一样，所以省略了。
	# p1=p(w0|c1)*p(w1|c1)*p(w2|c1)*p(c1)---->p1=logp(w0|c1)+logp(w1|c1)+logp(w2|c1)+log(c1)
    p1 = sum(vec2Classify * p1Vec) + log(pClass1)
    # 同上
    p0 = sum(vec2Classify * p0Vec) + log(1.0 - pClass1)
    if p1 > p0:
        return 1
    else: 
        return 0

def testingNB():
	'''
	function:便捷函数，都整合到这个函数里了
	'''
    listOPosts, listClasses = loadDataSet()
    myVocabList = createVocabList(listOPosts)
    trainMat=[]
    for postinDoc in listOPosts:
        trainMat.append(setOfWords2Vec(myVocabList, postinDoc))
    p0V,p1V,pAb = trainNB0(array(trainMat), array(listClasses))
    testEntry = ['love', 'my', 'dalmation']
    thisDoc = array(setOfWords2Vec(myVocabList, testEntry))
    print (testEntry, 'classified as: ', classifyNB(thisDoc, p0V, p1V, pAb))
    testEntry = ['stupid', 'garbage']
    thisDoc = array(setOfWords2Vec(myVocabList, testEntry))
    print(testEntry, 'classified as: ', classifyNB(thisDoc, p0V, p1V, pAb))

testingNB()

example_过滤垃圾邮件

# 接上面的部分

def bagOfWords2VecMN(vocabList, inputSet):
	'''
	function:由词集模型改为词袋模型，主要区别就是单词个数可以为多次
	'''
    returnVec = [0]*len(vocabList)
    for word in inputSet:
        if word in vocabList:
            returnVec[vocabList.index(word)] += 1
    return returnVec
    
def textParse(bigString):
    import re
    listOfTokens = re.split(r'\W+', bigString)
    # 将单词字母数大于两个的单子全部小写，
    return [tok.lower() for tok in listOfTokens if len(tok) > 2] 
    
def spamTest():
	'''
	function:主函数
	'''
	# docList是包含所有文本信息，一个邮件是一个列表；classList是邮件类别列表，1代表垃圾邮件；fullText是所有单词组成的列表
    docList=[]; classList = []; fullText =[]
    # 读取所有邮件的信息
    for i in range(1, 26):
        wordList = textParse(open('email/spam/%d.txt' % i).read())
        docList.append(wordList)
        fullText.extend(wordList)
        classList.append(1)
        wordList = textParse(open('email/ham/%d.txt' % i).read())
        docList.append(wordList)
        fullText.extend(wordList)
        classList.append(0)
    # 创建单词本
    vocabList = createVocabList(docList)
    trainingSet = list(range(50)); testSet=[]
	# 选取10个作为测试样本
    for i in range(10):
        randIndex = int(random.uniform(0,len(trainingSet)))
        testSet.append(trainingSet[randIndex])
        del(trainingSet[randIndex])  
    trainMat=[]; trainClasses = []
    # 训练样本，得到训练样本的数据集和对应类别
    for docIndex in trainingSet:
        trainMat.append(bagOfWords2VecMN(vocabList, docList[docIndex]))
        trainClasses.append(classList[docIndex])
	# 利用贝叶斯公式，得到p0V,p1V,pSpam
    p0V,p1V,pSpam = trainNB0(array(trainMat),array(trainClasses))
    errorCount = 0
    # 开始对测试样本进行计算
    for docIndex in testSet:        
        wordVector = bagOfWords2VecMN(vocabList, docList[docIndex])
        # 如果经过贝叶斯公式计算出的分类不对，那么错误数+1
        if classifyNB(array(wordVector),p0V,p1V,pSpam) != classList[docIndex]:
            errorCount += 1
            print ("classification error",docList[docIndex])
    print ('the error rate is: ',float(errorCount)/len(testSet))

spamTest()

后记

《机器学习实战》还有一个例子，但是我找不到数据集，就不做了，不过大体意思是一样的。都是利用贝叶斯公式来计算概率的。
这一次耗时还是比较长的，主要把时间花在理解贝叶斯公式上了，一定要静下心来看书上的解释，光看别人讲解是不够深刻的，这一章我反复看好几遍了，难点就是对与贝叶斯公式的理解，其实自己仔细看《统计学习方法》，一遍看不懂，就看下一遍，实在看不懂就去找下相关的博客辅助一下，就能搞的差不多!
感觉最近看书比较多，都没怎么敲代码，可能后面要穿插更新一些别的内容了（还是周更）。

这里强烈推荐B站一个宝藏UP机器学习系列 shuhuai008 机器学习白板推导，UP讲的非常详细，后面有些章节也可以学习，非常推荐！！！
白板推导
https://www.bilibili.com/video/BV1aE411o7qd
先验概率和后验概率
https://blog.csdn.net/snailpeople/article/details/86064687
最大似然估计和最大后验概率估计
https://blog.csdn.net/u011508640/article/details/72815981

really_not_Yanzu

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
《机器学习实战》（三）---朴素贝叶斯

朴素贝叶斯贝叶斯引入贝叶斯引入前两章分别介绍了K-近邻算法和决策树，现在有这样一个数据集，他由两类数据构成，数据分布如图，现有一个新的数据点（x,y）,如何简单快捷的将其分类成三角形/圆形？K近邻算法肯定可以算出来，但是为了这么一个小小的点计算量未免过大，决策树在这里好像就不是那么适用了。我们有一个非常自然的想法，能不能计算出这个点是三角形的概率p1，是圆形的概率p2，比较p1和p2，更大的...
复制链接

扫一扫