其他分享
首页 > 其他分享> > (3)机器学习实战笔记:朴素贝叶斯

(3)机器学习实战笔记:朴素贝叶斯

作者:互联网

优点:数据比较少的时候仍然有效,可以处理多类别问题 缺点:对于输入数据的准备方式比较敏感 适用的数据类型:标称型数据     将一组单词转换为一组数字 使用数字计算概率   著名应用:使用朴素贝叶斯过滤垃圾邮件 分类思路: (1)收集数据:提供文本文件 (2)准备数据:将文本文件解析成词条向量 (3)分析数据:检查词条确保解析的正确性 (4)训练算法:使用我们之前建立的trainNB0()函数 (5)测试算法:使用classifyNB(),构建一个新的测试函数来计算文档的错误率 (6)使用算法:构建一个完整的程度对一组文档进行分类,将错分的文档输出到屏幕上   切分文本:使用String.split()方法切分 为了更加精确地估计分类器错误率,需要进行多次迭代后求出平均错误率

 

——————————————————————————————-

简单实例:通过朴素贝叶斯分类实现垃圾邮件分类

通过对一邮件文本数据集进行处理(转化为向量)

经过朴素贝叶斯分类器进行分类可以判定是否为垃圾邮件

代码实现了简单的朴素贝叶斯分类器、文本向量转换器

详细备注见解释,下载数据集点这里

import numpy as np
from functools import reduce

#准备数据:从文本中构建词向量
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代表侮辱性词汇,0代表不是
    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)

#检查单词在第几篇文档(文档为inputSet向量)中出现
def setOfWords2Vec(vocabList,inputSet):
    #创建一个元素都为0的向量
    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

listOPosts,listClasses = loadDataSet()
myVocabList = createVocabList(listOPosts)
# print(myVocabList)
# print(setOfWords2Vec(myVocabList,listOPosts[0]))

#训练算法:词向量计算概率
#输入:文档矩阵trainMatrix、每类文档类别标签所构成向量trainCategory
def trainNB0(trainMatrix,trainCategory):
    numTrainDocs = len(trainMatrix)
    numWords = len(trainMatrix[0])#无重复单词表有几个单词

    #概率初始化
    pAbusive=sum(trainCategory)/float(numTrainDocs) #文档里脏话文档的概率
    p0Num = np.ones(numWords)#正向词汇列
    p1Num = np.ones(numWords)#脏话词汇列,都初始化为0
    #降低由概率值为0导致最后乘积为0的影响
    p0Denom=2.0
    p1Denom=2.0

    for i in range(numTrainDocs):
        #计算文档属于侮辱性文档(class=1)的概率P(1)
        #对于二分类问题可以通过1-P(1)得到P(0)
        #一旦某个词语在某文档中出现,该词对应的个数就加1
        #在所有的文档中,文档的总词数也相应+1,

        if trainCategory[i]==1: #对于脏话类词汇统计
            p1Num += trainMatrix[i] #统计脏话词汇数量,对应位置数量+1(单位就是1)
            p1Denom += sum(trainMatrix[i]) #总脏话词汇+出现次数
        else:
            p0Num += trainMatrix[i]
            p0Denom += sum(trainMatrix[i])

    p1Vect=p1Num/p1Denom
    p0Vect=p0Num/p0Denom

    return p0Vect,p1Vect,pAbusive

trainMat=[]
for postinDoc in listOPosts:
    trainMat.append(setOfWords2Vec(myVocabList,postinDoc))
    #统计经过处理的无重复词汇表中在对应第(postinDoc)文档中是否出现,是标记1,
    #返回len为文档长度的向量组
# print(trainMat)

p0V,p1V,pAb=trainNB0(trainMat,listClasses)
# print("0")
# print(p0V)
# print("1")
# print(p1V)
# print("A")
# print(pAb)
# print(myVocabList)

#朴素贝叶斯分类函数/输入向量(要分类的向量,使用函数trainNB0计算得到三个概率
def classifyNB(vec2Classify,p0Vec,p1Vec,pClass1):
    p1 = sum(vec2Classify*p1Vec)+np.log(pClass1)
    p0 = sum(vec2Classify*p0Vec)+np.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(np.array(trainMat),np.array(listClasses))
    testEntry=['love','my','dalmation']

    thisDoc = np.array(setOfWords2Vec(myVocabList,testEntry))
    print(testEntry,'classified as:',classifyNB(thisDoc,p0V,p1V,pAb))
    testEntry=['stupid','garbage']
    thisDoc = np.array(setOfWords2Vec(myVocabList,testEntry))
    print(testEntry,'classified as:',classifyNB(thisDoc,p0V,p1V,pAb))



testingNB()

#词袋模型:遇到每一个单词时,会增加词向量中对应值,而不是将对应数值设为0
def bagOfWords2VecMN(vocabList,inputSet):
    returnVec = [0]*len(vocabList)
    for word in inputSet:
        if word in vocabList:
            returnVec[vocabList.index(word)]+=1
    return returnVec

#应用:进行垃圾邮件的过滤

#切分文本

#test!
# mySent = 'This book is the best book on python or M.L. I have laid eyes upon.'
#
# import re
# regEx = re.compile('\\W*')
# listOfTokens = regEx.split(mySent)

#测试:使用朴素贝叶斯进行交叉验证
def textParse(bigString):
    import re
    listOfTokens =re.split(r'\W*',bigString)
    return[tok.lower() for tok in listOfTokens if len(tok)>2]
    #返回长度大于2的词,而且全部小写化



#该函数对贝叶斯垃圾邮件分类进行自动化处理,导入spam与ham下的文本文件,并为他们解析词列表。(*1)
#分离器所需要的概率计算只利用训练集中的文档来完成
#python变量trainingSet是一个整数列表,数值范围是0到49;(*2)



def spamTest():
    docList=[]
    classList=[]
    fullText=[]
    main_email=[]
    for i in range(1,26):
        #(*1)
        wordList = textParse(open('email/spam/%d.txt'%i).read())
        main_e=open('email/spam/%d.txt'%i).read()
        main_email.append(main_e)
        docList.append(wordList)
        fullText.extend(wordList)
        classList.append(1)

        wordList = textParse(open('email/ham/%d.txt'%i).read())
        docList.append(wordList)
        main_e= open('email/spam/%d.txt' % i).read()
        main_email.append(main_e)
        fullText.extend(wordList)
        classList.append(0)



    #构建词汇表
    vocabList = createVocabList(docList)
    # print("构建的vocabList:")
    # print(vocabList)
    # print("=========================================================")



    #进行测试集的划分 (*2)
    trainingSet = list(range(50))
    testSet=[]
    for i in range(10): #随机选择10个文件
        randIndex = int(np.random.uniform(0,len(trainingSet))) #随机构建测试集,获取随机数作为index
        testSet.append(trainingSet[randIndex])#把index对应的邮件index添加到测试集中
        del(trainingSet[randIndex])#并且把该index从待挑选名单中删除


    trainMat=[]
    trainClasses =[]
    for docIndex in trainingSet:
        #对于每一个训练集里的训练单位进行词向量的构建
        trainMat.append(setOfWords2Vec(vocabList,docList[docIndex]))
        trainClasses.append(classList[docIndex]) #安上对应标签!
    #针对训练集进行训练
    #
    # print(trainMat)
    # print(trainClasses)

    p0V,p1V,pSpam=trainNB0(np.array(trainMat),np.array(trainClasses))
    # print(p0V)

    errorCount = 0

    for docIndex in testSet:
        #提取训练名单上对应的邮件信息,查看滴docIndex条元素里对应的单词是否在vocablist词汇表中出现,出现则+1,返回信息向量wordVector
        # print("train")
        # print(docList[docIndex])
        wordVector = setOfWords2Vec(vocabList,docList[docIndex])
        # print(wordVector)

        if classifyNB(np.array(wordVector),p0V,p1V,pSpam)!=classList[docIndex]:
            errorCount +=1
            print(main_email[docIndex])
            print(classifyNB(np.array(wordVector), p0V, p1V, pSpam))
            print(classList[docIndex])




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

# spamTest()

#寻找最优参数


def findthebest_Data_test():
    docList = []
    classList = []
    fullText = []
    main_email = []
    for i in range(1, 26):
        # (*1)
        wordList = textParse(open('email/spam/%d.txt' % i).read())
        main_e = open('email/spam/%d.txt' % i).read()
        main_email.append(main_e)
        docList.append(wordList)
        fullText.extend(wordList)
        classList.append(1)

        wordList = textParse(open('email/ham/%d.txt' % i).read())
        docList.append(wordList)
        main_e = open('email/spam/%d.txt' % i).read()
        main_email.append(main_e)
        fullText.extend(wordList)
        classList.append(0)

    # 构建词汇表
    vocabList = createVocabList(docList)
    # print("构建的vocabList:")
    # print(vocabList)
    # print("=========================================================")

    # 进行测试集的划分 (*2)
    trainingSet = list(range(50))
    testSet = []
    for i in range(10):  # 随机选择10个文件
        randIndex = int(np.random.uniform(0, len(trainingSet)))  # 随机构建测试集,获取随机数作为index
        testSet.append(trainingSet[randIndex])  # 把index对应的邮件index添加到测试集中
        del (trainingSet[randIndex])  # 并且把该index从待挑选名单中删除

    trainMat = []
    trainClasses = []
    for docIndex in trainingSet:
        # 对于每一个训练集里的训练单位进行词向量的构建
        trainMat.append(setOfWords2Vec(vocabList, docList[docIndex]))
        trainClasses.append(classList[docIndex])  # 安上对应标签!
    # 针对训练集进行训练
    #
    # print(trainMat)
    # print(trainClasses)

    p0V, p1V, pSpam = trainNB0(np.array(trainMat), np.array(trainClasses))
    # print(p0V)

    errorCount = 0

    for docIndex in testSet:
        # 提取训练名单上对应的邮件信息,查看滴docIndex条元素里对应的单词是否在vocablist词汇表中出现,出现则+1,返回信息向量wordVector
        # print("train")
        # print(docList[docIndex])
        wordVector = setOfWords2Vec(vocabList, docList[docIndex])
        # print(wordVector)

        if classifyNB(np.array(wordVector), p0V, p1V, pSpam) != classList[docIndex]:
            errorCount += 1
            # print(main_email[docIndex])
            # print(classifyNB(np.array(wordVector), p0V, p1V, pSpam))
            # print(classList[docIndex])

    # print('the error rate is :', float(errorCount) / len(testSet))
    error_rate=float(errorCount) / len(testSet)
    return p0V, p1V, pSpam,error_rate

def find_the_data():
    p0Num = np.ones(10)
    p1Num = np.ones(10)
    PA = 0.0
    err=1
    for i in range(50):
        a,b,c,d=findthebest_Data_test()
        if d<err:
            err = d
            p0Num=a
            p1Num=b
            PA=c


    return p0Num,p1Num,PA



def final_test():
    p0,p1,pA =find_the_data()



    docList = []
    classList = []
    fullText = []
    main_email = []
    for i in range(1, 26):
        # (*1)
        wordList = textParse(open('email/spam/%d.txt' % i).read())
        main_e = open('email/spam/%d.txt' % i).read()
        main_email.append(main_e)
        docList.append(wordList)
        fullText.extend(wordList)
        classList.append(1)

        wordList = textParse(open('email/ham/%d.txt' % i).read())
        docList.append(wordList)
        main_e = open('email/spam/%d.txt' % i).read()
        main_email.append(main_e)
        fullText.extend(wordList)
        classList.append(0)

    vocabList = createVocabList(docList)

    errorCount = 0

    for i in range(len(docList)):
        # 提取训练名单上对应的邮件信息,查看滴docIndex条元素里对应的单词是否在vocablist词汇表中出现,出现则+1,返回信息向量wordVector
        # print("train")
        # print(docList[docIndex])
        wordVector = setOfWords2Vec(vocabList, docList[i])
        # print(wordVector)


        if classifyNB(np.array(wordVector), p0, p1, pA) != classList[i]:
            errorCount += 1
            # print(main_email[i])
            # print(classifyNB(np.array(wordVector), p0, p1, pA))
            # print(classList[i])

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



final_test()

 

 

标签:实战,vocabList,笔记,贝叶斯,np,docIndex,print,main,append
来源: https://www.cnblogs.com/AKsnoopy/p/14085074.html