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

朴素贝叶斯分类法，主要是通过训练学习联合概率分布。具体是学习先验概率和条件概率。 朴素贝叶斯法将实例分到后验概率最大分类中，实际上等价于期望风险最小化
朴素贝叶斯的参数估计有两种方式，一种是极大似然估计，另外一种是使用贝叶斯估计

数据集处理函数 词 表 到 向 暈 的 转 换 函 数

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 creatVocabList(dataSet):
    Set=set([])#创建一个空表
    for file in dataSet:
        Set =Set | set(file) #合并两个表
    return list(Set)

遍 历 文 档 中 的 所有 单 词 ， 如果 出 现 了 词 汇 表 中 的 单 词 ， 则 将 输 出 的 文 档 向 量 中 的 对 应值 设 为 1 每 当 遇 到 一 个 单 词 时 ， 它 会 增 加 词 向 量 中 的 对 应值 ， 而 不 只 是 将 对 应的数 值 设 为 1

def setofWord(vocablist,inputSet):
    returnVec=[0]*len(vocablist)
    for word in inputSet:
        if word in vocablist:
                returnVec[vocablist.index(word)]+=1
    return returnVec
训练函数  trainMatrix训练数据  trainlib 训练数据类别
def trainbayes(trainMatrix,trainlib):
    numTrainDocs = len(trainMatrix)  # 数据集的长度
    numWords = len(trainMatrix[0])
    PaA= sum(trainlib)/float(numTrainDocs)
    p0num=ones(numWords);p1num=ones(numWords)
    p0Denom=2.0;p1Denom=2.0
    for i in range(numTrainDocs):  # 遍历所有的数据集
        if trainlib[i] == 1:
            p1num +=trainMatrix[i]  #出现侮辱性词语 ，个数加1
            p1Denom += sum(trainMatrix[i])  # 总词数加1
        else:
            p0num +=trainMatrix[i]  # 对于没有侮辱词语 个数加一
            p0Denom += sum(trainMatrix[i])
    p1v = log(p1num/p1Denom) # 计侮辱性词语出现的概率
    p0v = log(p0num/p0Denom)
    return p0v,p1v,PaA

分类函数 如果 概率p1 >ｐ２ 就是侮辱性词语

def classifyB(needclassify,p0v,p1v,pclass):
    p1=sum(needclassify * p1v) + log(pclass)
    p0 = sum(needclassify * p0v) + log(1.0-pclass)
    if p1> p0:
        return 1  # 1 位侮辱性词汇
    else:
        return 0  # 0 不是侮辱性词汇

测试贝叶斯函数

def testingB():
    listOPosts,listClasses = loadDataSet()  # 初始化数据集
    myVocabList = creatVocabList(listOPosts)  #数据去重
    trainMat=[]
    for postinDoc in listOPosts:
        trainMat.append(setofWord(myVocabList, postinDoc))  #判断单词在数据集中是出现
    p0V,p1V,pAb =trainbayes(array(trainMat),array(listClasses))  # 获取概率
    testEntry = ['love', 'my', 'dalmation']
    thisDoc = array(setofWord(myVocabList, testEntry))
    print testEntry,u'分类为: ',classifyB(thisDoc,p0V,p1V,pAb)
    testEntry = ['stupid', 'garbage']
    thisDoc = array(setofWord(myVocabList, testEntry))
    print testEntry,u'分类为: ',classifyB(thisDoc,p0V,p1V,pAb)

文本进行处理函数 该 函 数 去 掉 少 于 两 个 字 符 的 字 符 串 ， 并 将 所 有 字 符 串 转 换 为 小 写

def textParse(bigString):
    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 = creatVocabList(docList)
    trainingSet = range(50); testSet=[]            #创建一个训练数组
    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:
        trainMat.append(setofWord(vocabList, docList[docIndex]))  # 构建词向量
        trainClasses.append(classList[docIndex])
    p0V,p1V,pSpam = trainbayes(array(trainMat),array(trainClasses))
    errorCount = 0
    for docIndex in testSet:        #对邮件进行分类
        wordVector = setofWord(vocabList, docList[docIndex])
        if classifyB(array(wordVector),p0V,p1V,pSpam) != classList[docIndex]:
            errorCount += 1
            print u"分类错误",docList[docIndex]
    print u'错误率: ',float(errorCount)/len(testSet)

朴素贝叶斯算法主要是基于一个贝叶斯假设 所有的数据都相互独立但是这在现实中是不可能的。但是使用贝叶斯进行推理效果是很好的，一般来说，使用贝叶斯网的效果会更好。
贝叶斯网络是一种概率网络，它是基于概率推理的图形化网络，而贝叶斯公式则是这个概率网络的基础。贝叶斯网络是基于概率推理的数学模型，所谓概率推理就是通过一些变量的信息来获取其他的概率信息的过程，基于概率推理的贝叶斯网络是为了解决不定性和不完整性问题而提出的，它对于解决复杂设备不确定性和关联性引起的故障有很大的优势。
一个完整的贝叶斯网络的构成包括网络的构建和网络的训练，一般来说，网络的构建是一个很复制的事情。贝叶斯网络的训练和隐马尔可夫模型类似但是相比马尔可夫链，贝叶斯网络更加复制。