贝叶斯分类器分类垃圾邮件

最新推荐文章于 2024-07-24 15:50:22 发布

淮北494

最新推荐文章于 2024-07-24 15:50:22 发布

阅读量574

点赞数

分类专栏：机器学习实验文章标签：算法分类人工智能 python

本文链接：https://blog.csdn.net/qq_62737390/article/details/127752052

版权

机器学习实验专栏收录该内容

2 篇文章 0 订阅

订阅专栏

1.文本切分和创建词汇表（词汇表就是将训练集中所有出现过的不同的单词全部集中到一起）

# -*- coding: UTF-8 -*-
import re

"""
函数说明:接收一个大字符串并将其解析为字符串列表

Parameters:
    无
Returns:
    无
"""
def textParse(bigString):                                                   # 定义字符串分割函数，参数为需要分割的大字符串
    listOfTokens = re.split(r'\W+', bigString)                              # 将大的字符串组转化成字符串列表，提取出来大小写字母，数字
    return [tok.lower() for tok in listOfTokens if len(tok) > 2]          # 将字符串列表中大写字母转化成小写字母，除了单个字母，例如大写的I，其它单词变成小写

"""
函数说明:将切分的实验样本词条整理成不重复的词条列表，也就是词汇表

Parameters:
    dataSet - 整理的样本数据集
Returns:
    vocabSet - 返回不重复的词条列表，也就是词汇表
"""
def createVocabList(dataSet):
    vocabSet = set([])                      #创建一个空的不重复列表
    for document in dataSet:               
        vocabSet = vocabSet | set(document) #取并集
    return list(vocabSet)                  

if __name__ == '__main__':
    docList = []; classList = []
    for i in range(1, 26):                                                  #遍历？？个txt文件  #遍历25个txt文件，准确为50个
        wordList = textParse(open('bayes_email/spam/%d.txt' % i, encoding='ISO-8859-1').read()) # 将每个文件所有字符当成大字符串，之后分割成列表
        docList.append(wordList)
        classList.append(1)                                                 #标记垃圾邮件，1表示？？？ #1表示为垃圾邮件
        wordList = textParse(open('bayes_email/ham/%d.txt' % i, encoding='ISO-8859-1').read())      #读取每个非垃圾邮件，并字符串转换成字符串列表
        docList.append(wordList)
        classList.append(0)                                                 #标记非垃圾邮件，0表示？？？# 0表示为非垃圾邮件
    vocabList = createVocabList(docList)                                    #创建词汇表，不重复
    print(vocabList)

2. 将每个垃圾邮件信息转化成向量，向量的长度等于词汇表的长度（如果一条邮件中包含词汇表中的单词，那么就把这个词汇表向量对应单词的索引位置变成1），这里有两种向量化的方法，第一种是词集模型，就是我上述说的那样，第二种是词袋模型，他是在上面的基础上，增加了词汇出现的个数（如new这个单词出现了两次，之后向量对应位置的值就不是1了而是2，出现更多次以此类推），原理上更说的通来了，但是增加了复杂性，特别是在进行拉普拉斯平滑的时候，无法操作，两种向量化的方式的具体代码如下：

"""
函数说明:根据vocabList词汇表，将inputSet向量化，向量的每个元素为1或0

Parameters:
    vocabList - createVocabList返回的列表
    inputSet - 切分的词条列表
Returns:
    returnVec - 文档向量,词集模型
"""
def setOfWords2Vec(vocabList, inputSet):
    returnVec = [0] * len(vocabList)                                     #创建一个其中所含元素都为0的向量
    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                                                    #返回文档向量

"""
函数说明:根据vocabList词汇表，构建词袋模型

Parameters:
    vocabList - createVocabList返回的列表
    inputSet - 切分的词条列表
Returns:
    returnVec - 文档向量,词袋模型
"""
def bagOfWords2VecMN(vocabList, inputSet):
    returnVec = [0]*len(vocabList)                                        #创建一个其中所含元素都为0的向量
    for word in inputSet:                                                #遍历每个词条
        if word in vocabList:                                            #如果词条存在于词汇表中，则计数加一
            returnVec[vocabList.index(word)] += 1
    return returnVec                                                    #返回词袋模型

3.接下来就是创建贝叶斯训练模型，求出先验概率，各种类条件概率

这里想说的一点是拉普拉斯平滑，就是说在计算类条件概率的时候，把所有的特征都加a（一般是1），分母加上该特征可能出现类别数（如颜色可能是红绿蓝，就加3）

"""
函数说明:朴素贝叶斯分类器训练函数

Parameters:
    trainMatrix - 训练文档矩阵，即setOfWords2Vec返回的returnVec构成的矩阵
    trainCategory - 训练类别标签向量，即loadDataSet返回的classVec
Returns:
    p0Vect - 非侮辱类的条件概率数组
    p1Vect - 侮辱类的条件概率数组
    pAbusive - 文档属于侮辱类的概率
"""
def trainNB0(trainMatrix,trainCategory):
    numTrainDocs = len(trainMatrix)                           #计算训练的文档数目
    numWords = len(trainMatrix[0])                            #计算每篇文档的词条数
    pAbusive = sum(trainCategory)/float(numTrainDocs)         # 计算不是垃圾邮件的先验概率
    p0Num = np.ones(numWords); p1Num = np.ones(numWords)    #创建numpy.ones数组,词条出现数初始化为1，拉普拉斯平滑
    p0Denom = 2.0; p1Denom = 2.0                            #分母初始化为2,拉普拉斯平滑
    for i in range(numTrainDocs):
        if trainCategory[i] == 1:                            #如果不是垃圾邮件，不是垃圾邮件的那个特征组++，非垃圾邮件总个数++
            p1Num += trainMatrix[i]
            p1Denom += trainCategory[i]  #sum(trainMatrix[i])
        else:                                                #如果是垃圾邮件，是垃圾邮件的那个对应特征组++，垃圾邮件总个数++
            p0Num += trainMatrix[i]
            p0Denom += 1#trainCategory[i]#sum(trainMatrix[i])
    p1Vect = np.log(p1Num/p1Denom)                            #取对数，防止下溢出         
    p0Vect = np.log(p0Num/p0Denom)         
    return p0Vect,p1Vect,pAbusive                            #返回？？？ #返回不是垃圾邮件的先验概率，垃圾邮件的条件概率数组，非垃圾邮件的条件概率数组

4.接下来是进行分类的函数


"""
函数说明:朴素贝叶斯分类器分类函数

Parameters:
    vec2Classify - 待分类的词条数组
    p0Vec - 非侮辱类的条件概率数组
    p1Vec -侮辱类的条件概率数组
    pClass1 - 文档属于侮辱类的概率
Returns:
    0 - 属于非侮辱类
    1 - 属于侮辱类
"""
def classifyNB(vec2Classify, p0Vec, p1Vec, pClass1):
    p1 = sum(vec2Classify * p1Vec) + np.log(pClass1)        #对应元素相乘。logA * B = logA + logB，所以这里加上log(pClass1)
    p0 = sum(vec2Classify * p0Vec) + np.log(1.0 - pClass1)
    if p1 > p0:
        return 1
    else:
        return 0

5.最后是将全部的代码整合到一起

"""
函数说明:测试朴素贝叶斯分类器

Parameters:
    无
Returns:
    无
"""
def spamTest():
    docList = []; classList = []; fullText = []
    for i in range(1, 26):                                                  #遍历25个txt文件
        wordList = textParse(open('bayes_email/spam/%d.txt' % i,  encoding='ISO-8859-1').read())     #读取每个垃圾邮件，并字符串转换成字符串列表
        docList.append(wordList)                                            #解释append函数，将垃圾邮件列表填入总列表中，以便获取词汇表
        fullText.append(wordList)
        classList.append(1)                                                 #标记垃圾邮件，1表示垃圾文件
        wordList = textParse(open('bayes_email/ham/%d.txt' % i,  encoding='ISO-8859-1').read())      #读取每个非垃圾邮件，并字符串转换成字符串列表
        docList.append(wordList)                                          
        fullText.append(wordList)
        classList.append(0)                                                                    #标记非垃圾邮件，0表示非垃圾邮件，请填写此句  
    vocabList = createVocabList(docList)                                    #创建词汇表，不重复
    trainingSet = list(range(50)); testSet = []                             #创建存储训练集的索引值的列表和测试集的索引值的列表                       
    for i in range(10):                                                     #从50个邮件中，随机挑选出？？个作为训练集,？？个做测试集
        randIndex = int(random.uniform(0, len(trainingSet)))                #随机选取索索引值
        testSet.append(trainingSet[randIndex])                              #添加测试集的索引值
        del(trainingSet[randIndex])                                         #在训练集列表中删除添加到测试集的索引值
    trainMat = []; trainClasses = []                                        #创建训练集矩阵和训练集类别标签系向量             
    for docIndex in trainingSet:                                            #遍历训练集
        trainMat.append(setOfWords2Vec(vocabList, docList[docIndex]))       # 将一个文本特征转化成向量并添加到trainMat中
        trainClasses.append(classList[docIndex])                            #将类别添加到训练集类别标签系向量中
    p0V, p1V, pSpam = trainNB0(np.array(trainMat), np.array(trainClasses))  #解释trainNBo函数中两个参数的含义，第一个参数特征矩阵，每行表示一个特征，列数表示训练集的个数，第二个参数是标签矩阵，表示该样本是垃圾邮件还是非垃圾邮件
    errorCount = 0                                                          #错误分类计数
    for docIndex in testSet:                                                #遍历测试集
        wordVector = setOfWords2Vec(vocabList, docList[docIndex])           #测试集的词集模型
        if classifyNB(np.array(wordVector), p0V, p1V, pSpam) != classList[docIndex]:    #如果分类错误
            errorCount += 1                                                 #错误计数加1
            print("分类错误的测试集：",docList[docIndex])
                                                                            #用print输出错误率，请填写此句


if __name__ == '__main__':
    spamTest()