机器学习实战笔记--朴素贝叶斯

  1 #encoding:utf-8
  2 from numpy import *
  3 import feedparser
  4
  5 #加载数据集
  6 def loadDataSet():
  7     postingList = [[‘my‘, ‘dog‘, ‘has‘, ‘flea‘, ‘problems‘, ‘help‘, ‘please‘],
  8                    [‘maybe‘, ‘not‘, ‘take‘, ‘him‘, ‘to‘, ‘dog‘, ‘park‘, ‘stupid‘],
  9                    [‘my‘, ‘dalmation‘, ‘is‘, ‘so‘, ‘cute‘, ‘I‘, ‘love‘, ‘him‘],
 10                    [‘stop‘, ‘posting‘, ‘stupid‘, ‘worthless‘, ‘garbage‘],
 11                    [‘mr‘, ‘licks‘, ‘ate‘, ‘my‘, ‘steak‘, ‘how‘, ‘to‘, ‘stop‘, ‘him‘],
 12                    [‘quit‘, ‘buying‘, ‘worthless‘, ‘dog‘, ‘food‘, ‘stupid‘]]
 13     classVec = [0, 1, 0, 1, 0, 1]  # 1表示侮辱性言论,0表示正常言论
 14     return postingList, classVec
 15
 16
 17 def createVocabList(dataSet):  #得到词汇集合
 18     vocabSet = set([])
 19     for document in dataSet:
 20         vocabSet = vocabSet | set(document)  #两个集合的并集
 21     return list(vocabSet)
 22
 23
 24 def setOfWords2Vec(vocabList, inputSet):  #内容转化为向量
 25     returnVec = [0] * len(vocabList)   #所有元素都为0的向量
 26     for word in inputSet:
 27         if word in vocabList:
 28             returnVec[vocabList.index(word)] = 1   #如果有这个词条,则置1
 29         else:
 30             print "这个词条: %s 不在我的词典中!" % word
 31     return returnVec
 32
 33
 34 def trainNB0(trainMatrix, trainCategory):   #朴素贝叶斯分类器训练函数
 35     numTrainDocs = len(trainMatrix)          #文档数量
 36     numWords = len(trainMatrix[0])           #每篇文档的词条数
 37     pAbusive = sum(trainCategory) / float(numTrainDocs)   #侮辱性文档的比例
 38     p0Num = ones(numWords)
 39     p1Num = ones(numWords)  # change to ones()
 40     p0Denom = 2.0
 41     p1Denom = 2.0  # change to 2.0
 42     for i in range(numTrainDocs):
 43         if trainCategory[i] == 1:
 44             p1Num += trainMatrix[i]
 45             p1Denom += sum(trainMatrix[i])   #侮辱性文档的总词数
 46         else:
 47             p0Num += trainMatrix[i]
 48             p0Denom += sum(trainMatrix[i])  #正常文档的总词数
 49     p1Vect = log(p1Num / p1Denom)  # change to log()  表示p(wi/c1)
 50     p0Vect = log(p0Num / p0Denom)  # change to log()  表示p(wi/c0)
 51     return p0Vect, p1Vect, pAbusive
 52
 53
 54 def classifyNB(vec2Classify, p0Vec, p1Vec, pClass1):    #对输入的vec2Classify进行分类
 55     p1 = sum(vec2Classify * p1Vec) + log(pClass1)  # element-wise mult
 56     p0 = sum(vec2Classify * p0Vec) + log(1.0 - pClass1)
 57     if p1 > p0:
 58         return 1
 59     else:
 60         return 0
 61
 62
 63 def testingNB():   #是对以上方法的整合,方便运行和调试
 64     listOPosts, listClasses = loadDataSet()   #加载数据
 65     myVocabList = createVocabList(listOPosts)   #得到字典
 66     trainMat = []
 67     for postinDoc in listOPosts:
 68         trainMat.append(setOfWords2Vec(myVocabList, postinDoc))     #转化为0,1向量
 69     p0V, p1V, pAb = trainNB0(array(trainMat), array(listClasses))
 70     testEntry = [‘love‘, ‘my‘, ‘dalmation‘]           #代分类的输入
 71     thisDoc = array(setOfWords2Vec(myVocabList, testEntry))    #转化
 72     print testEntry, ‘classified as: ‘, classifyNB(thisDoc, p0V, p1V, pAb)   #进行分类
 73     testEntry = [‘stupid‘, ‘garbage‘]
 74     thisDoc = array(setOfWords2Vec(myVocabList, testEntry))
 75     print testEntry, ‘classified as: ‘, classifyNB(thisDoc, p0V, p1V, pAb)
 76
 77
 78 def bagOfWords2VecMN(vocabList, inputSet):
 79     returnVec = [0] * len(vocabList)
 80     for word in inputSet:
 81         if word in vocabList:
 82             returnVec[vocabList.index(word)] += 1
 83     return returnVec
 84
 85
 86 def textParse(bigString):  # 处理字符串得到字符串列表,并过滤
 87     import re
 88     listOfTokens = re.split(r‘\W*‘, bigString)
 89     return [tok.lower() for tok in listOfTokens if len(tok) > 2]
 90
 91 #垃圾邮件测试函数
 92 def spamTest():
 93     docList = [];
 94     classList = [];
 95     fullText = []
 96     for i in range(1, 26):
 97         wordList = textParse(open(‘email/spam/%d.txt‘ % i).read())   #读取文件
 98         docList.append(wordList)         #注意append和extend
 99         fullText.extend(wordList)
100         classList.append(1)
101         wordList = textParse(open(‘email/ham/%d.txt‘ % i).read())
102         docList.append(wordList)
103         fullText.extend(wordList)
104         classList.append(0)
105     vocabList = createVocabList(docList)  # 建立字典
106     trainingSet = range(50);
107     testSet = []
108     for i in range(10):
109         randIndex = int(random.uniform(0, len(trainingSet)))   #随机取10个作为测试集
110         testSet.append(trainingSet[randIndex])
111         del (trainingSet[randIndex])    #从训练集中删除
112     trainMat = [];
113     trainClasses = []
114     for docIndex in trainingSet:  # 训练
115         trainMat.append(bagOfWords2VecMN(vocabList, docList[docIndex]))
116         trainClasses.append(classList[docIndex])
117     p0V, p1V, pSpam = trainNB0(array(trainMat), array(trainClasses))
118     errorCount = 0
119     for docIndex in testSet:  # 分类
120         #wordVector = bagOfWords2VecMN(vocabList, docList[docIndex])
121         wordVector = setOfWords2Vec(vocabList, docList[docIndex])
122         if classifyNB(array(wordVector), p0V, p1V, pSpam) != classList[docIndex]:
123             errorCount += 1
124             print "classification error", docList[docIndex]
125     print ‘the error rate is: ‘, float(errorCount) / len(testSet)
126     # return vocabList,fullText
127
128
129 def calcMostFreq(vocabList, fullText):   #计算出现频率
130     import operator
131     freqDict = {}
132     for token in vocabList:
133         freqDict[token] = fullText.count(token)
134     sortedFreq = sorted(freqDict.iteritems(), key=operator.itemgetter(1), reverse=True)  #排序
135     return sortedFreq[:30]  #返回前30
136
137
138 def localWords(feed1, feed0):
139     import feedparser
140     docList = [];
141     classList = [];
142     fullText = []
143     minLen = min(len(feed1[‘entries‘]), len(feed0[‘entries‘]))
144     for i in range(minLen):
145         wordList = textParse(feed1[‘entries‘][i][‘summary‘])    #每次访问一条RSS源
146         docList.append(wordList)
147         fullText.extend(wordList)
148         classList.append(1)  # NY is class 1
149         wordList = textParse(feed0[‘entries‘][i][‘summary‘])
150         docList.append(wordList)
151         fullText.extend(wordList)
152         classList.append(0)
153     vocabList = createVocabList(docList)  # 建立字典
154     top30Words = calcMostFreq(vocabList, fullText)  # 去掉次数最高的前30个词
155     for pairW in top30Words:
156         if pairW[0] in vocabList: vocabList.remove(pairW[0])
157     trainingSet = range(2 * minLen);
158     testSet = []  # create test set
159     for i in range(20):
160         randIndex = int(random.uniform(0, len(trainingSet)))
161         testSet.append(trainingSet[randIndex])
162         del (trainingSet[randIndex])
163     trainMat = [];
164     trainClasses = []
165     for docIndex in trainingSet:  # train the classifier (get probs) trainNB0
166         trainMat.append(bagOfWords2VecMN(vocabList, docList[docIndex]))
167         trainClasses.append(classList[docIndex])
168     p0V, p1V, pSpam = trainNB0(array(trainMat), array(trainClasses))
169     errorCount = 0
170     for docIndex in testSet:  # classify the remaining items
171         wordVector = bagOfWords2VecMN(vocabList, docList[docIndex])
172         if classifyNB(array(wordVector), p0V, p1V, pSpam) != classList[docIndex]:
173             errorCount += 1
174     print ‘the error rate is: ‘, float(errorCount) / len(testSet)
175     return vocabList, p0V, p1V
176
177
178 def getTopWords(ny, sf):
179     import operator
180     vocabList, p0V, p1V = localWords(ny, sf)
181     topNY = [];
182     topSF = []
183     for i in range(len(p0V)):
184         if p0V[i] > -6.0: topSF.append((vocabList[i], p0V[i]))
185         if p1V[i] > -6.0: topNY.append((vocabList[i], p1V[i]))
186     sortedSF = sorted(topSF, key=lambda pair: pair[1], reverse=True)
187     print "SF**SF**SF**SF**SF**SF**SF**SF**SF**SF**SF**SF**SF**SF**SF**SF**"
188     for item in sortedSF:
189         print item[0]
190     sortedNY = sorted(topNY, key=lambda pair: pair[1], reverse=True)
191     print "NY**NY**NY**NY**NY**NY**NY**NY**NY**NY**NY**NY**NY**NY**NY**NY**"
192     for item in sortedNY:
193         print item[0]
194
195 if __name__ == ‘__main__‘:
196     # postingList, classVec = loadDataSet()
197     # vocabList = createVocabList(postingList)
198     # trainMat = []
199     # for line in postingList:
200     #     trainMat.append(setOfWords2Vec(vocabList,line))
201     # p0V,p1V,p = trainNB0(trainMat,classVec)
202     # print p0V
203     # print p1V
204     # print p
205     # spamTest()
206     ny = feedparser.parse(‘http://newyork.craigslist.org/stp/index.rss‘)
207     sf = feedparser.parse(‘http://sfbay.craigslist.org/stp/index.rss‘)
208     getTopWords(ny,sf)
时间: 2024-10-13 12:20:23

机器学习实战笔记--朴素贝叶斯的相关文章

4.机器学习实战之朴素贝叶斯

返回目录 上一篇:决策树 1. 简单理论介绍 1.1  贝叶斯定理 了解贝叶斯定理之前,需要先了解下条件概率.P(A|B)表示在事件B已经发生的条件下事件A发生的概率: P(A|B)=P(AB)  P(B)daf afdfd 假如我们已经知道了P(A|B),但是现在我们想要求P(B|A),也就是在事件A发生的条件下事件B发生的概率,这时贝叶斯定理就派上用场了. P(B|A)=P(A|B)P(B)  P(A)daf afdfd 1.2  朴素贝叶斯分类原理 朴素贝叶斯分类是以贝叶斯定理为基础的,之

《机器学习实战》笔记——朴素贝叶斯

运用贝叶斯公式(朴素贝叶斯假设每个特征每个特征都是独立的)可以解决的问题有,已知某些特征,用来判断某情况发生的可能性大小,设置可能性最大的情况作为预测值. 是一种监督算法. 广泛应用于垃圾邮件检测等等. 1 # _*_coding:utf-8_*_ 2 from numpy import * 3 4 # 4-1 词表到向量的转换函数(实验样本) 5 def loadDataSet(): 6 postingList = [['my', 'dog', 'has', 'flea', 'problems

机器学习算法:朴素贝叶斯

朴素贝叶斯(Naive Bayesian)算法的核心思想是:分别计算给定样本属于每个分类的概率,然后挑选概率最高的作为猜测结果. 假定样本有2个特征x和y,则其属于分类1的概率记作p(C1|x,y),它的值无法直接分析训练样本得出,需要利用公式间接求得. 其中p(Ci)表示训练样本中分类为Ci的概率,它等于Ci样本数除以样本总数. p(x,y)表示满足2个特征的样本概率,它等于第1特征等于x且第2特征等于y的样本数除以样本总数.可以发现p(x,y)与当前在计算哪个分类概率是无关的,因此实际计算中

机器学习之路--朴素贝叶斯

一,引言 前两章的KNN分类算法和决策树分类算法最终都是预测出实例的确定的分类结果,但是,有时候分类器会产生错误结果:本章要学的朴素贝叶斯分类算法则是给出一个最优的猜测结果,同时给出猜测的概率估计值. 1 准备知识:条件概率公式 相信学过概率论的同学对于概率论绝对不会陌生,如果一时觉得生疏,可以查阅相关资料,在这里主要是想贴出条件概率的计算公式: P(A|B)=P(A,B)/P(B)=P(B|A)*P(A)/P(B) 2 如何使用条件概率进行分类 假设这里要被分类的类别有两类,类c1和类c2,那

吴裕雄--天生自然python机器学习:使用朴素贝叶斯过滤垃圾邮件

使用朴素贝叶斯解决一些现实生活中 的问题时,需要先从文本内容得到字符串列表,然后生成词向量. 准备数据:切分文本 测试算法:使用朴素贝叶斯进行交叉验证 文件解析及完整的垃圾邮件测试函数 def createVocabList(dataSet): vocabSet = set([]) #create empty set for document in dataSet: vocabSet = vocabSet | set(document) #union of the two sets return

【机器学习模型】朴素贝叶斯

一.啥是贝叶斯公式 1.公式定义: 贝叶斯公式是由英国数学家贝叶斯发展,用来描述两个条件概率之间的关系,比如P(A|B)和P(B|A). 按照乘法法则,可以立刻导出:P(A∩B) = P(A)*P(B|A)=P(B)*P(A|B).如上公式也可变形为:P(B|A) = P(A|B)*P(B) / P(A),即为贝叶斯公式 假设B是由相互独立的事件组成的概率空间{B1,b2,...bn}.则P(A)可以用全概率公式展开:P(A)=P (A|B1)P(B1)+P(A|B2)P(B2)+..P(A|B

Spark机器学习(4):朴素贝叶斯算法

1. 贝叶斯定理 条件概率公式: 这个公式非常简单,就是计算在B发生的情况下,A发生的概率.但是很多时候,我们很容易知道P(A|B),需要计算的是P(B|A),这时就要用到贝叶斯定理: 2. 朴素贝叶斯分类 朴素贝叶斯分类的推导过程就不详述了,其流程可以简单的用一张图来表示: 举个简单的例子来说,下面这张表说明了各地区的人口构成: 这个时候如果一个黑皮肤的人走过来(一个待分类项(0,0,1)),他是来自欧美,亚洲还是非洲呢?可以根据朴素贝叶斯分类进行计算: 欧美=0.30×0.90×0.20×0

机器学习—朴素贝叶斯

机器学习-朴素贝叶斯 本文代码均来自<机器学习实战> 朴素贝叶斯的两个基本假设: 独立:一个特征出现的可能性和与它和其他特征相邻没有关系 每个特征同等重要 这段代码是以文本分类为例介绍朴素贝叶斯算法的 要从文本中获取特征,需要先拆分文本.这里的特征是来自文本的词条(token),一个词条是字符的任意组合.可以把词条想象为单词,也可以使用非单词词条,如URL.IP地址或者任意其他字符串.然后将一个文本片段表示为一个词向量,其中值为1表示词条出现,0表示词条未出现. ??以在线社区的留言板为例,为

《机器学习实战》学习笔记:基于朴素贝叶斯的分类方法

概率是许多机器学习算法的基础,在前面生成决策树的过程中使用了一小部分关于概率的知识,即统计特征在数据集中取某个特定值的次数,然后除以数据集的实例总数,得到特征取该值的概率. 目录: 一.基于贝叶斯理论的分类方法 二.关于朴素贝叶斯的应用场景 三.基于Python和朴素贝叶斯的文本分类 1.准备数据 2.训练算法 3.测试算法 四.小结 以下进入正文: 一.基于贝叶斯理论的分类方法 假设有两类数据组成的数据集如下: 其中,假设两个概率分布的参数已知,并用p1(x,y)表示当前数据点(x,y)属于类