机器学习实验报告——Bayes算法

朴素贝叶斯一个很重要的应用就是文本分类，所以我们以在线社区留言为例。为了不影响社区的发展，我们要屏蔽侮辱性的言论，所以要构建一个快速过滤器，如果某条留言使用了负面或者侮辱性的语言，那么就将该留言标志为内容不当。过滤这类内容是一个很常见的需求。对此问题建立两个类型：侮辱类和非侮辱类，使用1和0分别表示。

我们把文本看成单词向量或者词条向量，也就是说将句子转换为向量。考虑出现所有文档中的单词，再决定将哪些单词纳入词汇表或者说所要的词汇集合，然后必须要将每一篇文档转换为词汇表上的向量。简单起见，我们先假设已经将本文切分完毕，存放到列表中，并对词汇向量进行分类标注。

所用到的函数

loadDataSet：创建实验数据集

createVocabList：生成词汇表

setOfWords2Vec：生成词向量

get_trainMat：所有词条向量列表

trainNB：朴素贝叶斯分类器训练函数

classifyNB：朴素贝叶斯分类器分类函数

testingNB：朴素贝叶斯测试函数

3.2代码实现

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?is?abusive,?0?not
????return?postingList,classVec
?????????????????
def?createVocabList(dataSet):
????vocabSet?=?set([])??#create?empty?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)
????p0Num?=?ones(numWords);?p1Num?=?ones(numWords)??????#change?to?ones()?
????p0Denom?=?2.0;?p1Denom?=?2.0????????????????????????#change?to?2.0
????for?i?in?range(numTrainDocs):
????????if?trainCategory[i]?==?1:
????????????p1Num?+=?trainMatrix[i]
????????????p1Denom?+=?sum(trainMatrix[i])
????????else:
????????????p0Num?+=?trainMatrix[i]
????????????p0Denom?+=?sum(trainMatrix[i])
????p1Vect?=?log(p1Num/p1Denom)??????????#change?to?log()
????p0Vect?=?log(p0Num/p0Denom)??????????#change?to?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?bagOfWords2VecMN(vocabList,?inputSet):
????returnVec?=?[0]*len(vocabList)
????for?word?in?inputSet:
????????if?word?in?vocabList:
????????????returnVec[vocabList.index(word)]?+=?1
????return?returnVec

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?(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?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.iteritems(),?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])

根据给定的实验结果，我们可以看到两个示例样本的分类结果：

['love', 'my', 'dalmation']?被分类为?0，即非有害类别。这是因为这个样本中包含了一些正面的词汇，如?"love"?和?"dalmation"，而这些词汇在非有害样本中出现的频率较高。

['stupid', 'garbage']?被分类为?1，即有害类别。这是因为这个样本中包含了一些负面的词汇，如?"stupid"?和?"garbage"，而这些词汇在有害样本中出现的频率较高。

总的来说，贝叶斯分类器通过学习文本数据中词汇的出现概率，可以对新的文本样本进行分类。然而，该算法的性能还取决于训练数据的质量和特征表示的选择。

四、实验讨论

4.1算法优缺点

（1）优点

朴素贝叶斯模型发源于古典数学理论，有稳定的分类效率。

对小规模的数据表现很好，能个处理多分类任务，适合增量式训练。

对缺失数据不太敏感，算法也比较简单，常用于文本分类。

（2）缺点

理论上，朴素贝叶斯模型与其他分类方法相比具有最小的误差率。但是实际上并非总是如此，这是因为朴素贝叶斯模型给定输出类别?的情况下，假设属性之间相互独立，这个假设在实际应用中往往是不成立的，在属性个数比较多或者属性之间相关性较大时，分类效果不好。而在属性相关性较小时，朴素贝叶斯性能最为良好。

需要知道先验概率，且先验概率很多时候取决于假设，假设的模型可以有很多种，因此在某些时候会由于假设的先验模型的原因导致?预测效果不佳。

由于是通过先验和数据来决定后验的概率从而决定分类，所以分类决策存在一定的错误率。

对输入数据的表达形式很敏感。

4.2关于三种朴素贝叶斯算法使用场合的讨论

在scikit-learn中，一共有3个朴素贝叶斯的分类算法。分别是GaussianNB，MultinomialNB和BernoulliNB。

(1) GaussianNB

GaussianNB就是先验为高斯分布（正态分布）的朴素贝叶斯，假设每个标签的数据都服从简单的正态分布。

其中??为Y的第k类的类别。?和?为需要从训练集估计的值。

(2) MultinomialNB

MultinomialNB就是先验为多项式分布的朴素贝叶斯。它假设特征是由一个简单多项式分布生成的。多项分布可以描述各种类型样本出现次数的概率，因此多项式朴素贝叶斯非常适合用于描述出现次数或者出现次数比例的特征。

该模型常用于文本分类，特征表示的是次数，例如某个词语的出现次数。多项式分布公式如下：

其中，P(=|Y=)是第?k?个类别的第j维特征的第l个取值条件概率。是训练集中输出为第k类的样本个数。?λ为一个大于0的常数，λ通常取1，即为拉普拉斯平滑。

(3) BernoulliNB

BernoulliNB就是先验为伯努利分布的朴素贝叶斯。假设特征的先验概率为二元伯努利分布，即如下式：

其中，只有两种取值，只能取值为0或1。

在伯努利模型中，每个特征的取值是布尔型的，即true和false，或者1和0。在文本分类中，就是一个特征有没有在一个文档中出现。

一般来说：

如果样本特征的分布大部分是连续值，使用GaussianNB会比较好;

如果样本特征的分布大部分是多元离散值，使用MultinomialNB比较合适;

如果样本特征是二元离散值或者很稀疏的多元离散值，应该使用BernoulliNB。

4.3关于朴素贝叶斯算法中拉普拉斯平滑修正的讨论

拉普拉斯平滑修正是朴素贝叶斯分类算法中常用的一种平滑技术，用于处理在计算条件概率时可能出现的零概率问题。虽然拉普拉斯平滑修正在某些情况下能够提高模型的鲁棒性和泛化能力，但也存在一些讨论和争议。

过度平滑：有些研究人员认为，拉普拉斯平滑修正可能会引入过度平滑的问题，即对于已经有足够样本支撑的特征，添加额外的伪计数反而会导致条件概率的估计偏离真实情况。这可能会影响模型对数据的拟合能力，使得模型过于简化，错失一些细微的模式。

对大规模数据的影响：在大规模数据集上，拉普拉斯平滑修正可能不如在小规模数据集上有效。因为在大规模数据集上，很多特征都能够获得足够数量的样本支持，不需要额外的平滑来保证条件概率的计算。

其他平滑方法：除了拉普拉斯平滑，还有其他平滑方法，如Lidstone平滑、Good-Turing估计等，它们也可以用于解决零概率问题，并且在不同情况下可能表现更好。

在实际应用中，是否使用拉普拉斯平滑修正取决于数据集的特点以及具体的建模需求。研究人员和实践者们需要根据具体情况权衡平滑方法的利弊，并结合交叉验证等方法选择最适合的方案。

4.4朴素贝叶斯算法的应用

朴素贝叶斯算法是一种简单而有效的分类算法，它在文本分类、垃圾邮件过滤、情感分析等领域有广泛的应用。以下是一些朴素贝叶斯算法的应用示例：

文本分类：朴素贝叶斯算法在文本分类任务中表现出色。它可以通过学习训练集中文本的特征（如单词、词频等）和对应的类别标签，建立一个分类模型。在测试阶段，根据新的文本特征，使用朴素贝叶斯算法计算后验概率，从而将文本分到相应的类别中。

垃圾邮件过滤：朴素贝叶斯算法被广泛应用于垃圾邮件过滤。通过学习已知的垃圾邮件和非垃圾邮件的特征，如发件人、主题、内容等，朴素贝叶斯算法可以对新的邮件进行分类，判断其是否为垃圾邮件。

情感分析：朴素贝叶斯算法可以用于情感分析，即对文本进行情感分类（如正面、负面、中性）。通过学习带有情感标签的文本样本，朴素贝叶斯算法可以根据文本的特征（词汇、句法结构等）来判断其情感倾向。

金融风险预测：在金融领域，朴素贝叶斯算法可以用于预测风险和评估潜在投资项目。通过学习历史数据和与风险相关的特征，朴素贝叶斯算法可以根据当前特征对未来可能的风险进行概率估计。

医学诊断：朴素贝叶斯算法在医学领域中也有应用。它可以利用患者的症状、疾病历史等特征，通过学习已知的病例数据，进行疾病的分类和诊断。

需要注意的是，朴素贝叶斯算法基于独立性假设，即每个特征之间是相互独立的，这在现实情况下并不总是成立。因此，在实际应用中，我们需要根据具体问题和数据的特点，合理选择适当的特征和算法，以获得更好的分类效果。

五、实验总结

本次实验探讨了贝叶斯算法的原理，区分了贝叶斯算法与朴素贝叶斯算法的关系，即贝叶斯算法是一种基于贝叶斯定理进行概率推断的方法，而朴素贝叶斯算法是贝叶斯算法在分类问题上的一种具体应用。

然后对朴素贝叶斯算法进行介绍，并在条件概率及独立性检验的基础上推导算法公式。

在算法实现部分，我采用的朴素贝叶斯实现文档分类实验。以在线社区留言为例。为了不影响社区的发展，我们要屏蔽侮辱性的言论，所以要构建一个快速过滤器，如果某条留言使用了负面或者侮辱性的语言，那么就将该留言标志为内容不当。过滤这类内容是一个很常见的需求。

最终的分类结果符合预期，证明了该算法的高效性。

在算法讨论部分，我们讨论了朴素贝叶斯算法的优缺点，优点是简单高效，适用于大规模数据集。缺点是假设特征之间相互独立，这在实际情况中可能不成立。

另外讨论的三种朴素贝叶斯算法即GaussianNB，MultinomialNB和BernoulliNB。他们在不同的场合有着各自的优势，需要根据具体情况权衡平滑方法的利弊，并结合交叉验证等方法选择最适合的方案。

总之，通过此次实验，对贝叶斯算法有了更深的认识和理解。贝叶斯算法是一种基于贝叶斯定理的概率模型推断方法，可以对未知参数进行估计和预测，并提供了一种在不确定性和变化中进行决策的框架。贝叶斯算法可以利用先验分布和后验分布来描述不确定性，并通过贝叶斯公式更新后验分布。这是一种常用的机器学习算法，在分类、回归和聚类等领域都有广泛的应用。

2024-1-22

文章来源:https://blog.csdn.net/m0_64198455/article/details/135740709
本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若内容造成侵权/违法违规/事实不符，请联系我的编程经验分享网邮箱：chenni525@qq.com进行投诉反馈，一经查实，立即删除！