机器学习--贝叶斯分类算法及应用

朴素贝叶斯分类器

　　朴素贝叶斯分类器的表示形式：

　　当特征为为x时，计算所有类别的条件概率，选取条件概率最大的类别作为待分类的类别。由于上公式的分母对每个类别都是一样的，因此计算时可以不考虑分母，即

　　朴素贝叶斯的朴素体现在其对各个条件的独立性假设上，加上独立假设后，大大减少了参数假设空间。　　

0

0

0

1

1

0

a、这么差的衣服以后再也不买了

b、帅，有逼格

……

1

?

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]

    return postingList, classVec

# 创建一个包含在所有文档中出现的不重复词的列表

def createVocabList(dataSet):

    vocabSet = set([])      #创建一个空集

    for document in​dataSet:

        vocabSet = vocabSet | set(document)   #创建两个集合的并集

    return list(vocabSet)

​

#将文档词条转换成词向量

def setOfWords2Vec(vocabList, inputSet):

    returnVec = [0]*len(vocabList)        #创建一个其中所含元素都为0的向量

    for word in inputSet:

        if word in vocabList:

            #returnVec[vocabList.index(word)] = 1     #index函数在字符串里找到字符第一次出现的位置  词集模型

            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 = zeros(numWords); p1Num = zeros(numWords)

    #p0Denom = 0.0; p1Denom = 0.0

p0Num = ones(numWords);   #避免一个概率值为0,最后的乘积也为0

p1Num = ones(numWords);   #用来统计两类数据中，各词的词频     

p0Denom = 2.0;  #用于统计0类中的总数

p1Denom = 2.0  #用于统计1类中的总数

    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 = p1Num / p1Denom

    #p0Vect = p0Num / p0Denom

    p1Vect = log(p1Num /​p1Denom)    #在类1中，每个次的发生概率

    p0Vect = log(p0Num /​p0Denom)      #避免下溢出或者浮点数舍入导致的错误   下溢出是由太多很小的数相乘得到的

    return p0Vect, p1Vect, pAbusive

#朴素贝叶斯分类器

def classifyNB(vec2Classify, p0Vec, p1Vec, pClass1):

    p1 = sum(vec2Classify*p1Vec) + log(pClass1)

    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​testEntry, 'classified as: ', classifyNB(thisDoc, p0V, p1V, pAb)

    testEntry = ['stupid','garbage']

    thisDoc = array(setOfWords2Vec(myVocabList, testEntry))

    printtestEntry, 'classified as: ', classifyNB(thisDoc, p0V, p1V, pAb)

>>>reload(bayes)

from ‘bayes.py’>

>>>bayes.testingNB()

['love','my','dalmation']​classified as: 0

['stupid','garbage'] classifiedas: 1

#过滤垃圾邮件

def textParse(bigString):      #正则表达式进行文本解析

    import re

    listOfTokens = re.split(r'\W*',bigString)

    return [tok.lower() for tok in listOfTokens if len(tok) > 2]

​

def spamTest():

    docList = []; classList = []; fullText = []

    fori 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 = range(50);testSet = []

    fori in range(10):                         #随机构建训练集

        randIndex = int(random.uniform(0,len(trainingSet)))

        testSet.append(trainingSet[randIndex])    #随机挑选一个文档索引号放入测试集

        del(trainingSet[randIndex])              #将该文档索引号从训练集中剔除

    trainMat = []; trainClasses = []

    fordocIndex in trainingSet:

        trainMat.append(setOfWords2Vec(vocabList, docList[docIndex]))

        trainClasses.append(classList[docIndex])

    p0V, p1V, pSpam = trainNB0(array(trainMat), array(trainClasses))

    errorCount = 0

    fordocIndex in testSet:              #对测试集进行分类

        wordVector = setOfWords2Vec(vocabList, docList[docIndex])

        if classifyNB(array(wordVector), p0V, p1V, pSpam) != classList[docIndex]:

            errorCount += 1

    print 'the error rate is: ', float(errorCount)/len(testSet)