《machine learning in action》机器学习 算法学习笔记 基于概率论的分类方法:朴素贝叶斯

基于概率论的分类方法:朴素贝叶斯
优点:在数据较少的情况下仍然有效(但是准确率也属于一言难尽),可以处理多类别问题。
缺点:对于输入数据的方式较为敏感。
适用数据类型:标称型数据。

前置知识:条件概率,贝叶斯决策理论,相互独立

相互独立:相互独立是设A,B是两事件,如果满足等式 P ( A B ) = P ( A ) P ( B ) P(AB)=P(A)P(B) P(AB)=P(A)P(B),则称事件A,B相互独立,简称A,B独立。

条件概率 P ( g r e y ∣ b u c k e t B ) P(grey|bucketB) P(greybucketB)表示的是在该球取自B桶的条件下,该球为灰色的概率。

条件概率计算方法
P ( B ∣ A ) = P ( A B ) P ( A ) P(B|A)=\frac{P(AB)}{P(A)} P(BA)=P(A)P(AB)
贝叶斯准则:

通过条件概率公式代换,得到 P ( A ∣ B ) P(A|B) P(AB)​和 P ( B ∣ A ) P(B|A) P(BA)​之间的转换方法:
p ( A ∣ B ) = P ( B ∣ A ) P ( A ) P ( B ) p(A|B)=\frac{P(B|A)P(A)}{P(B)} p(AB)=P(B)P(BA)P(A)
贝叶斯决策理论

核心思想:选择概率最高的决策

  • 如果 p 1 ( x , y ) > p 2 ( x , y ) p1(x,y)>p2(x,y) p1(x,y)>p2(x,y)​​,则(x,y)属于1类

  • 如果 p 1 ( x , y ) < p 2 ( x , y ) p1(x,y)<p2(x,y) p1(x,y)<p2(x,y),则(x,y)属于2类

综合以上的内容,最终的到贝叶斯分类准则

  • 如果 p ( c 1 ∣ x , y ) > p ( c 2 ∣ x , y ) p(c_1|x,y)>p(c_2|x,y) p(c1x,y)>p(c2x,y),那么(x,y)属于1类
  • 如果 p ( c 1 ∣ x , y ) < p ( c 2 ∣ x , y ) p(c_1|x,y)<p(c_2|x,y) p(c1x,y)<p(c2x,y)​,那么(x,y)属于2类

样本数:

在进行分类是,特征数决定着样本数,由统计学知,如果每个特征需要N个样本,那么对于M个特征需要 N M N^M NM个样本,该数量是指数爆炸的。

假如特征之间相互独立,那么所需要的样本数可以从 N M N^M NM下降到 N ∗ M N*M NM

使用朴素贝叶斯进行文档分类

该方法中将单词作为特征,特征数巨大。

朴素“:

单词的分布实际上是相互影响的,一些特定语法,一些固定搭配。该方法采用以特征之间相互独立为前提,对文档进行分类,故为朴素,目的也是为了使用更少的样本。

  • 准备数据:从文本中构建词向量

  • 训练算法:从词向量计算概率

根据贝叶斯分类准则,我们需要求得 P ( c 0 ∣ w ) P(c_0|w) P(c0w) P ( c 1 ∣ w ) P(c_1|w) P(c1w)​,其中w是由多个单词(特征)组成的词向量。

首先,由贝叶斯准则,的到:
P ( c 0 ∣ w ) = P ( w ∣ c 0 ) P ( C 0 ) P ( w ) P(c_0|w)=\frac{P(w|c_0)P(C_0)}{P(w)} P(c0w)=P(w)P(wc0)P(C0)
其次,由”朴素“假设得
P ( w ∣ c 0 ) = P ( w 1 , w 2 , … , w n ∣ c 0 ) = P ( w 1 ∣ c 0 ) P ( w 2 ∣ c 0 ) … P ( w n ∣ c 0 ) P(w|c_0)=P(w_1,w_2,\dots,w_n|c_0)=P(w_1|c_0)P(w_2|c_0)\dots P(w_n|c_0) P(wc0)=P(w1,w2,,wnc0)=P(w1c0)P(w2c0)P(wnc0)
便可以得到以下伪代码:

计算每个类别中的文档数目
对每篇训练文档:
   	对每个类别:
    	如果词条出现文档中->增加该词条的计数值
    	增加所有词条的计数值
 对每个类别:
 	对每个词条:
 		将该词条的数目除以总词条数目得到条件概率
 返回每个类别的条件概率

该代码在实现过程中运用了numpy的特性。

并且本书中的一些地方也没有讲清楚:

如:

def classifyNB(vec2Classify, p0Vec, p1Vec, pClass1):
    p1 = sum(vec2Classify * p1Vec) + log(pClass1)  # element-wise mult
    p0 = sum(vec2Classify * p0Vec) + log(1.0 - pClass1)
    if p1 > p0:
        return 1
    else:
        return 0

计算p1,p2时为何要加log(),为什么是概率相加,不应该是相乘吗?

CSDN大佬给出了答案,对其进行吸收和整理:

在解决下溢问题(多个极小数相乘时,会出现精度消失)时,所以我们可以使用 l o g ( x ∗ y ) = l o g ( x ) + l o g ( y ) log(x*y)=log(x)+log(y) log(xy)=log(x)+log(y)这个特性。

之所以可以使用,是因为log函数,和概率函数的分布形态近视:

在这里插入图片描述

那么以上的代码就被很好的解释了。

实例:使用朴素贝叶斯过滤垃圾邮件

收集数据:提供文本文件。
准备数据:将文本文件解析成词条向量。
分析数据:检查词条确保解析的正确性。
训练算法:使用我们之前建立的trainNB0()函数。
测试算法:使用classifyNB(),并且构建一个新的测试函数来计算文档集的错误率。
使用算法:构建一个完整的程序对一组文档进行分类,将错分的文档输出到屏幕上。

利用正则表达式切分文本

import re
mySent='This book is the best book on python or M.L. i have ever laid eyes upon.'
regEx = re.compile('\\W')#\W表示非单词数字的字符
listOfTkens = regEx.split(mySent)#split()表示以mySent作为分割标志切割字符
to=[tok.lower() for tok in listOfTkens if len(tok)>0]#去掉长度为0的空串,且大小写不影响侮辱性
print(listOfTkens)
print(to)

留存交叉验证:从数据集中选择一定数量的作为测试集,剩余的用于训练。

实例:使用朴素贝叶斯分类器从个人广告获取区域倾向。

收集数据:从RSS源收集内容,这里需要对RSS源构建一个接口
准备数据:将文本文件解析成词条向量。
分析数据:检查词条确保解析的正确性。
训练算法:使用我们之前建立的trainNB0()函数。
测试算法:观察错误率,确保分类器可用。
使用算法:构建一个完整的程序对一组文档进行分类,将错分的文档输出到屏幕上。

使用了去除出现次数最多的30个词的方式降低错误率,这是由于语言中大部分的冗余造成的。

bayes.py

from numpy import *

#-----------------------------词表到向量的转换------------------------------------
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']]
    classVec = [0, 1, 0, 1, 0, 1]  # 标签,1表示带有侮辱性,0表示没有。
    return postingList, classVec

#---------------------------------建立词典-----------------------------------
def createVocabList(dataSet):
    vocabSet = set([])  # 获取特征
    for document in dataSet:
        vocabSet = vocabSet | set(document)  # union of the two sets,集合取并
    return list(vocabSet)

#-------------------检查待分类的词向量的特征是否都出现在词典中------------------------
def setOfWords2Vec(vocabList, inputSet):
    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):#前者为在字典中出现的文档词向量,后者为标签向量
    numTrainDocs = len(trainMatrix)
    numWords = len(trainMatrix[0])
    pAbusive = sum(trainCategory) / float(numTrainDocs)#P(c1)
    p0Num = ones(numWords)
    p1Num = ones(numWords)  # change to ones()
    p0Denom = 2.0
    p1Denom = 2.0  # 优化,由于是概率相乘,但有一个为0时,整体概率会为0,防止出现该现象,故将所有词的出现次数初始化为1,分母初始化为2
    for i in range(numTrainDocs):
        if trainCategory[i] == 1:
            p1Num += trainMatrix[i]#array类型,存放的是每个单词出现的次数,整体相加,方便
            p1Denom += sum(trainMatrix[i])
        else:
            p0Num += trainMatrix[i]#array类型,存放的是每个单词出现的次数,整体相加,方便
            p0Denom += sum(trainMatrix[i])
    p1Vect = log(p1Num / p1Denom)  # 解决下溢问题,当多个较小的数相乘时,数值会很小,会出现精度丢失问题,利用激活函数调整分布
    p0Vect = log(p0Num / p0Denom)  # change to log(),log函数与概率密度函数特征类似,且不会出现下溢问题。
    return p0Vect, p1Vect, pAbusive


def classifyNB(vec2Classify, p0Vec, p1Vec, pClass1):
    p1 = sum(vec2Classify * p1Vec) + log(pClass1)  # element-wise mult
    p0 = sum(vec2Classify * p0Vec) + log(1.0 - pClass1)
    if p1 > p0:
        return 1
    else:
        return 0

def testingNB():
    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(thisDoc)
    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))

def bagOfWords2VecMN(vocabList, inputSet):
    returnVec = [0] * len(vocabList)
    for word in inputSet:
        if word in vocabList:
            returnVec[vocabList.index(word)] += 1
    return returnVec

def textParse(bigString):  # input is big string, #output is word list
    import re
    listOfTokens = re.split(r'\W*', bigString)
    return [tok.lower() for tok in listOfTokens if len(tok) > 2]


def spamTest():
    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)  # create vocabulary
    trainingSet = range(50)
    testSet = []  # create test set
    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:  # train the classifier (get probs) trainNB0
        trainMat.append(bagOfWords2VecMN(vocabList, docList[docIndex]))
        trainClasses.append(classList[docIndex])
    p0V, p1V, pSpam = trainNB0(array(trainMat), array(trainClasses))
    errorCount = 0
    for docIndex in testSet:  # classify the remaining items
        wordVector = bagOfWords2VecMN(vocabList, docList[docIndex])
        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))
    # return vocabList,fullText


def calcMostFreq(vocabList, fullText):
    import operator
    freqDict = {}
    for token in vocabList:
        freqDict[token] = fullText.count(token)
    sortedFreq = sorted(freqDict.items(), key=operator.itemgetter(1), reverse=True)
    return sortedFreq[:30]


def localWords(feed1, feed0):
    import feedparser
    docList = []
    classList = []
    fullText = []
    minLen = min(len(feed1['entries']), len(feed0['entries']))
    for i in range(minLen):
        wordList = textParse(feed1['entries'][i]['summary'])
        docList.append(wordList)
        fullText.extend(wordList)
        classList.append(1)  # NY is class 1
        wordList = textParse(feed0['entries'][i]['summary'])
        docList.append(wordList)
        fullText.extend(wordList)
        classList.append(0)
    vocabList = createVocabList(docList)  # create vocabulary
    top30Words = calcMostFreq(vocabList, fullText)  # remove top 30 words
    for pairW in top30Words:
        if pairW[0] in vocabList: vocabList.remove(pairW[0])
    trainingSet = range(2 * minLen)
    testSet = []  # create test set
    for i in range(20):
        randIndex = int(random.uniform(0, len(trainingSet)))
        testSet.append(trainingSet[randIndex])
        del (trainingSet[randIndex])
    trainMat = []
    trainClasses = []
    for docIndex in trainingSet:  # train the classifier (get probs) trainNB0
        trainMat.append(bagOfWords2VecMN(vocabList, docList[docIndex]))
        trainClasses.append(classList[docIndex])
    p0V, p1V, pSpam = trainNB0(array(trainMat), array(trainClasses))
    errorCount = 0
    for docIndex in testSet:  # classify the remaining items
        wordVector = bagOfWords2VecMN(vocabList, docList[docIndex])
        if classifyNB(array(wordVector), p0V, p1V, pSpam) != classList[docIndex]:
            errorCount += 1
    print('the error rate is: ', float(errorCount) / len(testSet))
    return vocabList, p0V, p1V


def getTopWords(ny, sf):
    import operator
    vocabList, p0V, p1V = localWords(ny, sf)
    topNY = []
    topSF = []
    for i in range(len(p0V)):
        if p0V[i] > -6.0:
            topSF.append((vocabList[i], p0V[i]))
        if p1V[i] > -6.0:
            topNY.append((vocabList[i], p1V[i]))
    sortedSF = sorted(topSF, key=lambda pair: pair[1], reverse=True)
    print("SF**SF**SF**SF**SF**SF**SF**SF**SF**SF**SF**SF**SF**SF**SF**SF**")
    for item in sortedSF:
        print(item[0])
    sortedNY = sorted(topNY, key=lambda pair: pair[1], reverse=True)
    print("NY**NY**NY**NY**NY**NY**NY**NY**NY**NY**NY**NY**NY**NY**NY**NY**")
    for item in sortedNY:
        print(item[0])

main.py

import re
import bayes
listOPosts,listClasses=bayes.loadDataSet()
myVocabList=bayes.createVocabList(listOPosts)
print(myVocabList)
print(bayes.setOfWords2Vec(myVocabList,listOPosts[0]))
trainMat = []
for postinDoc in listOPosts:
    trainMat.append(bayes.setOfWords2Vec(myVocabList,postinDoc))
print(trainMat)#得到的是每一句话在字典中的分布
p0v,p1v,pAb=bayes.trainNB0(trainMat,listClasses)
print(pAb)
print(p0v)
print(p1v)
bayes.testingNB()
mySent='This book is the best book on python or M.L. i have ever laid eyes upon.'
regEx = re.compile('\\W')#\W表示非单词数字的字符
listOfTkens = regEx.split(mySent)#split()表示以mySent作为分割标志切割字符
to=[tok for tok in listOfTkens if len(tok)>0]#去掉长度为0的空串
print(listOfTkens)
print(to)

结语:

  • 利用概率论的知识对事物进行分类是一种很自然的想法,基于统计学的知识,取得出一个结果,这也是对数理知识的一种应用。
  • 再改模型中使用了特征之间的条件独立的假设,这也是能够快速求得概率的原因,虽然与事实不符,但在特定的数据集上表现十分好,可以将该方法作为模型化简方法之一。
  • 根据语言的冗余性,移除出现频次高的词汇,反而降低了错误率,是一种很好的数据预处理的方法。
  • 通过使用log( )函数来解决乘数下溢问题十分有技巧性。
  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
好的,我可以向你介绍一下朴素贝叶斯分类和k近邻学习的基本算法,并提供Python实现的示例代码。 1. 朴素贝叶斯分类 朴素贝叶斯分类是一种基于统计学和概率论分类方法,它假设每个特征之间相互独立,从而简化了分类的计算。它的基本思想是根据已知类别的样本,计算出每个特征在不同类别下的概率,并利用贝叶斯公式计算出待分类样本属于每个类别的概率,最后选择概率最大的类别作为分类结果。 以下是一个简单的朴素贝叶斯分类的Python实现示例: ```python import numpy as np class NaiveBayes: def __init__(self): self.classes = None self.mean = None self.var = None def fit(self, X, y): self.classes = np.unique(y) n_classes = len(self.classes) n_features = X.shape[1] self.mean = np.zeros((n_classes, n_features)) self.var = np.zeros((n_classes, n_features)) for i, c in enumerate(self.classes): X_c = X[y == c] self.mean[i, :] = X_c.mean(axis=0) self.var[i, :] = X_c.var(axis=0) def gaussian_pdf(self, X, mean, var): exponent = np.exp(-((X - mean) ** 2 / (2 * var))) return np.prod(1 / np.sqrt(2 * np.pi * var) * exponent, axis=1) def predict(self, X): y_pred = [] for x in X: posteriors = [] for i, c in enumerate(self.classes): prior = np.sum(y == c) / len(y) likelihood = self.gaussian_pdf(x, self.mean[i, :], self.var[i, :]) posterior = prior * likelihood posteriors.append(posterior) y_pred.append(self.classes[np.argmax(posteriors)]) return y_pred ``` 2. k近邻学习 k近邻学习是一种基于实例的学习方法,它通过查找邻近的训练样本来预测待分类样本的类别。它的基本思路是选择k个最近邻的样本,根据它们的类别来决定待分类样本的类别,通常采用投票法或加权投票法来决定。 以下是一个简单的k近邻学习的Python实现示例: ```python import numpy as np from collections import Counter class KNN: def __init__(self, k=3): self.k = k def euclidean_distance(self, X1, X2): return np.sqrt(np.sum((X1 - X2) ** 2, axis=1)) def predict(self, X_train, y_train, X_test): y_pred = [] for x in X_test: distances = self.euclidean_distance(X_train, x) k_nearest_idx = np.argsort(distances)[:self.k] k_nearest_labels = y_train[k_nearest_idx] most_common_label = Counter(k_nearest_labels).most_common(1)[0][0] y_pred.append(most_common_label) return y_pred ``` 注意:以上示例代码仅供参考,实际使用时需要根据具体问题进行调整和优化。

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值