【机器学习实战06】贝叶斯网络

最新推荐文章于 2024-06-19 23:36:11 发布

小松悦读会 | kevinelstri

最新推荐文章于 2024-06-19 23:36:11 发布

阅读量2.3k

点赞数 1

分类专栏： Python 机器学习实战机器学习实战文章标签：机器学习

本文链接：https://blog.csdn.net/kevinelstri/article/details/52268566

版权

Python 同时被 3 个专栏收录

61 篇文章 4 订阅

订阅专栏

机器学习实战

11 篇文章 0 订阅

订阅专栏

机器学习实战

10 篇文章 15 订阅

订阅专栏

1、概率知识

条件概率：事件A在另外一个事件B已经发生条件下的发生概率。表示：P(A|B)记作 “在B条件下A的概率”

乘法定理：设P(A)>0，则有
这里写图片描述

全概率公式：如果事件B1,B2,B3….Bn构成一个完备事件组，即两两互不相容，其和为全集，且P(Bi)>0，则对任一事件A来说：
这里写图片描述

贝叶斯公式：设实验E的样本空间为S，A为E的事件，B1,B2,B3…..Bn为S的一个划分，切事件的概率都大于0，于是贝叶斯公式：
这里写图片描述
利用乘法定理，既然P(AB)=P(B|A)P(A)，那么P(AB)=P(B|A)P(A)=P(A|B)P(B).那么就可以转换为：

2、基于贝叶斯决策理论的分类方法

首先对于一个数据集而言：

这里写图片描述

使用p1(x,y)表示数据点(x,y)属于类别1的概率，用p2(x,y)表示数据点(x,y)属于类别2的概率，那么对于一个新数据点(x,y)，可以使用以下规则进行判断：
如果p1(x,y)>p2(x,y)，那么类别为1，
如果p1(x,y)<p2(x,y)，那么类别为2。
也就是说，选择高概率对应的类别，这也就是贝叶斯决策理论的核心思想，选择具有最高概率的决策。

区别：

使用KNN算法，需要进行10000次距离计算
使用决策树，分别沿x轴、y轴划分数据
使用类别概率，比较类别概率大小来进行判断

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

朴素贝叶斯是用于文档分类的常用算法。
特征：观察文档中出现的词，并把每个词的出现或者不出现作为一个特征。这样便有跟文档中出现过词汇的个数一样多的特征。
有大量特征时，使用直方图效果更好。

朴素贝叶斯假设：
1、一个特征出现的概率，与其他特征（条件）独立（特征独立性）
2、每个特征同等重要（特征均衡性）

4、使用python进行文本分类

从文本中提取特征，首先拆分文本，将文本转化为词向量，某个词存在表示为1，不存在表示为0，这样，原来一大串字符串便转为简单的0，1序列的向量。当然也可以转为更为复杂的向量，根据不同词出现的频率等等。

（1）准备数据：从文本中构建词向量

#encoding:utf-8

from numpy import *

    #创建实验样本，真实样本可能差很多，需要对真实样本做一些处理，比如
    #去停用词(stopwords)，词干化(stemming)等等，处理完后得到更"clear"的数据集，方便后续处理

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 createVocabList(dataSet):

    #将所有文档所有（去重的）词都存到一个列表中，可用set()函数去重。 
    #用上set()函数操作符号|，取并集，或者写两重循环用vocabSet.add() 
    #return list(set([word for doc in dataSet for word in doc]) 
    #[word for doc in dataSet for word in doc]: 用列表推导式将dataSet转为1维列表， 
    #set(XXX)： 将这个列表去重转为集合 
    #list(set(XXX)): 又转回来 

    vocabSet = set([])  #创建一个空集合
    for document in dataSet:
        vocabSet = vocabSet | set(document) #创建两个集合的并集，去除重复元素
    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 #输出文档向量，向量的每一元素为1或0，分别表示词汇表中的单词在输入文档中是否出现

#测试：

listOPosts,listClasses = loadDataSet()
myVocabList = createVocabList(listOPosts)
print myVocabList #在输出的这个此表中，不会出现重复的词

print "\n"

Vec = setOfWords2Vec(myVocabList, listOPosts[5])
print Vec

Output:

['cute', 'love', 'help', 'garbage', 'quit', 'I', 'problems', 'is', 'park', 'stop', 'flea', 'dalmation', 'licks', 'food', 'not', 'him', 'buying', 'posting', 'has', 'worthless', 'ate', 'to', 'maybe', 'please', 'dog', 'how', 'stupid', 'so', 'take', 'mr', 'steak', 'my']


[0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0]

（2）训练算法：从词向量计算概率

伪代码：
计算每个类别中的文档总数
对每篇训练文档
      对每个类别：
          如果词条出现在文档中–>增加该词条的计数值
          增加所有词条的计数值
       对每个类别：
          对每个词条：
              将该词条的数目除以总词条数目得到条件概率
      返回每个类别的条件概率

#coding=utf-8

from numpy import *

# 加载数据集函数
def loadDataSet():
    # 定义邮件列表
    postingList = [['my','dog','has','flea',\
                    'problem','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——abusive，0——not abusive
    classVec = [0,1,0,1,0,1]
    return postingList,classVec

# 创建词汇列表
def createVocabList(dataSet):
    # 定义词汇集
    vocabSet = set([])
    # 遍历文档
    for document in dataSet:
        # 将每个document合并到vocabSet，|用来联合两个集合
        vocabSet = vocabSet | set(document)
    # 返回词汇集
    return list(vocabSet)

# 把单词转换成向量,通过单词的索引结果来显示单词存在性，存在为1，不存在为0
def setOfWords2Vec(vocabList,inputSet):#参数：vocabList词汇表，inputSet邮件列表
    # 定义要返回的向量
    returnVec = [0] * len(vocabList)
    # 遍历输出集中的单词
    for word in inputSet:
        # 单词在词汇集中
        if word in vocabList:
            # 对应的位置设为1
            returnVec[vocabList.index(word)] = 1
        else:
            print "the word: %s is not in my Vocabulary!" % word
    # 返回向量
    return returnVec

# 把单词转换成向量,用词袋模型，计算词出现的次数
def bagOfWords2VecMN(vocabList,inputSet):#参数：vocabList词汇表，inputSet邮件列表
    # 定义要返回的向量
    returnVec = [0] * len(vocabList)
    # 遍历输出集中的单词
    for word in inputSet:
        # 单词在词汇集中
        if word in vocabList:
            # 对应的词出现次数 加1
            returnVec[vocabList.index(word)] += 1
    # 返回向量
    return returnVec


# 条件概率的计算
def trainNB0(trainMatrix,trainCategory): #输入参数为文档矩阵trainMatrix,文档类别所构成的向量trainCategory
    # 计算文档的数目
    numTrainDocs = len(trainMatrix)
    # 计算单词的数目
    numWords = len(trainMatrix[0])
    # 计算类别的概率，abusive为1，not abusive为0
    pAbusive =sum(trainCategory) / float(numTrainDocs)
    # 初始化计数器，1行numWords列，p0是not abusive
    # p0Num =zeros(numWords)
    p0Num = ones(numWords)
    # 初始化计数器，p1是abusive
    p1Num = ones(numWords)
    # 初始化分母
    p0Denom = 2.0
    p1Denom = 2.0
    # 遍历文档
    for i in range(numTrainDocs):
        # 计算abusive对应的词汇的数目，trainMatrix为0-1值形成的向量
        if trainCategory[i] == 1:
            # p1Num存储的是每个词出现的次数
            p1Num += trainMatrix[i]
            # p1Denom存储的是词的总数目
            p1Denom += sum(trainMatrix[i])
        # 计算not abusive词汇的数目
        else:
            # 每个词在not abusive下出现的次数
            p0Num += trainMatrix[i]
            # not abusive下的总词数
            p0Denom += sum(trainMatrix[i])
    # 计算abusive下每个词出现的概率
    # p1Vect = p1Num / p1Denom
    p1Vect = log(p1Num / p1Denom)
    # 计算not abusive下每个词出现的概率
    # p0Vect = p0Num / p0Denom
    p0Vect = log(p0Num / p0Denom)
    # 返回词出现的概率和文档为abusive的概率，not abusive的概率为1-pAbusive
    return p0Vect,p1Vect,pAbusive

def classifyNB(vec2Classify,p0Vec,p1Vec,pClass1):
    # 计算abusive的概率
    p1 = sum(vec2Classify * p1Vec) + log(pClass1)
    # 计算not abusive的概率
    p0 = sum(vec2Classify * p0Vec) + log(1.0 - pClass1)
    # 根据概率大小判断属于哪个类
    if p1 > p0:
        return 1
    else:
        return 0

# 测试
def testingNB():
    # 加载数据集
    listOPosts,listClass = loadDataSet()
    # 创建词汇列表
    myVocabList = createVocabList(listOPosts)
    trainMat = []
    for postinDoc in listOPosts:
        trainMat.append(setOfWords2Vec(myVocabList,postinDoc))
    p0V,p1V,pAb = trainNB0(array(trainMat),array(listClass))
    # print p0V,p1V,pAb
    # print trainMat
    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)

#test:
testpos = testingNB()
print testpos

# 文本解析   
# 输入是字符串，输出是单词列表
def textParse(bigString):    
    # 导入正则表达式的包
    import re
    # 用正则表达式分割字符串
    listOfTokens = re.split(r'\W*', bigString)
    # 返回小写单词列表
    return [tok.lower() for tok in listOfTokens if len(tok) > 2] 

#test:
print "\n"
bigString = textParse("100% MoneyBack Guaranteeed")
print bigString

# 垃圾邮件测试   
def spamTest():

    docList=[] #定义docList文档列表，
    classList = [] #classList类别列表，
    fullText =[] #fullText所有文档词汇
    # 遍历email/spam和email/ham下的txt文件
    for i in range(1,26):
        # 定义并读取垃圾邮件文件的词汇分割列表
        wordList = textParse(open('email/spam/%d.txt' % i).read())
        # 将词汇列表加到文档列表中
        docList.append(wordList)
        # 将所有词汇列表汇总到fullText中
        fullText.extend(wordList)
        # 文档类别为1，spam
        classList.append(1)
        # 读取非垃圾邮件的文档
        wordList = textParse(open('email/ham/%d.txt' % i).read())
        # 添加到文档列表中
        docList.append(wordList)
        # 添加到所有词汇列表中
        fullText.extend(wordList)
        # 类别为0，非垃圾邮件
        classList.append(0)
    # 创建词汇列表
    vocabList = createVocabList(docList)
    # 定义训练集的索引和测试集
    trainingSet = range(50) 
    testSet=[]
    # 随机的选择10个作为测试集      
    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中
        trainMat.append(bagOfWords2VecMN(vocabList, docList[docIndex]))
        # 训练集的类别标签
        trainClasses.append(classList[docIndex])
    # 计算先验概率，条件概率
    p0V,p1V,pSpam = trainNB0(array(trainMat),array(trainClasses))
    # 定义错误计数
    errorCount = 0
    # 对测试集进行分类
    for docIndex in testSet: 
        # 将测试集词汇向量化      
        wordVector = bagOfWords2VecMN(vocabList, docList[docIndex])
        # 对测试数据进行分类
        if classifyNB(array(wordVector),p0V,p1V,pSpam) != classList[docIndex]:
            # 分类不正确，错误计数加1
            errorCount += 1
            print "classification error",docList[docIndex]
    # 输出错误率
    print 'the error rate is: ',float(errorCount)/len(testSet)

#test:
print "\n"
data = spamTest()
print data

小松悦读会 | kevinelstri

关注

1
点赞
踩
5

收藏

觉得还不错? 一键收藏
2
评论
【机器学习实战06】贝叶斯网络

1、概率知识条件概率：事件A在另外一个事件B已经发生条件下的发生概率。表示：P(A|B)记作 “在B条件下A的概率”乘法定理：设P(A)>0，则有全概率公式：如果事件B1,B2,B3….Bn构成一个完备事件组，即两两互不相容，其和为全集，且P(Bi)>0，则对任一事件A来说：
复制链接

扫一扫

专栏目录