机器学习实战—— Chap04.NaiveBayes

Bertha 。 2023-06-16 02:25 13阅读 0赞

import numpy as np
    from functools import reduce
    
    """
    Desc:
        创建实验样本
        
    Parameters:
        None
        
    Returns:
        postingList - 实验样本切分的词条
        classVec - 类别标签向量
    """
    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
    
    
    """
    Desc:
        根据vocabList词汇表，将inputSet向量化，向量的每个元素为1或0
        
    Parameters:
        vocabList - createVocabList返回的列表
        inputSet - 切分的词条列表
        
    Returns:
        returnVec - 文档向量，词集模型
    """
    def setOfWords2Vec(vocabList, inputSet):
        # 创建一个其中所含元素都为0的向量
        returnVec = [0] * len(vocabList)
        # 遍历每个词条
        for word in inputSet:
            if word in vocabList:
                # 如果词条存在于词汇表中，则置1
                # index返回word出现在vocabList中的索引
                # 若这里改为+=则就是基于词袋的模型，遇到一个单词会增加单词向量中德对应值
                returnVec[vocabList.index(word)] = 1
            else:
                print("the word: %s is not in my Vocabulary" % word)
        # 返回文档向量
        return returnVec
    
    
    """
    Desc:
        将切分的实验样本词条整理成不重复的词条列表，也就是词汇表
        
    Parameters:
        dataSet - 整理的样本数据集
        
    Returns:
        vocabSet - 返回不重复的词条列表，也就是词汇表
    """
    def createVocabList(dataSet):
        # 创建一个空的不重复列表
        # set是一个无序且不重复的元素集合
        vocabSet = set([])
        for document in dataSet:
            # 取并集
            vocabSet = vocabSet | set(document)
        return list(vocabSet)
    
    
    """
    Desc:
        朴素贝叶斯分类器训练函数
        
    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)
        # 创建numpy.zeros数组，词条出现数初始化为0
        # p0Num = np.zeros(numWords)
        # p1Num = np.zeros(numWords)
        # 创建numpy.ones数组，词条出现数初始化为1,拉普拉斯平滑
        p0Num = np.ones(numWords)
        p1Num = np.ones(numWords)
        # 分母初始化为0
        # p0Denom = 0.0
        # p1Denom = 0.0
        # 分母初始化为2，拉普拉斯平滑
        p0Denom = 2.0
        p1Denom = 2.0
        for i in range(numTrainDocs):
            # 统计属于侮辱类的条件概率所需的数据，即P(w0|1),P(w1|1),P(w2|1)...
            if trainCategory[i] == 1:
                # 统计所有侮辱类文档中每个单词出现的个数
                p1Num += trainMatrix[i]
                # 统计一共出现的侮辱单词的个数
                p1Denom += sum(trainMatrix[i])
            # 统计属于非侮辱类的条件概率所需的数据，即P(w0|0),P(w1|0),P(w2|0)...
            else:
                # 统计所有非侮辱类文档中每个单词出现的个数
                p0Num += trainMatrix[i]
                # 统计一共出现的非侮辱单词的个数
                p0Denom += sum(trainMatrix[i])
        # 每个侮辱类单词分别出现的概率
        # p1Vect = p1Num / p1Denom
        # 取对数，防止下溢出
        p1Vect = np.log(p1Num / p1Denom)
        # 每个非侮辱类单词分别出现的概率
        # p0Vect = p0Num / p0Denom
        # 取对数，防止下溢出
        p0Vect = np.log(p0Num / p0Denom)
        # 返回属于侮辱类的条件概率数组、属于非侮辱类的条件概率数组、文档属于侮辱类的概率
        return p0Vect, p1Vect, pAbusive
                    
    
    """
    Desc:
        朴素贝叶斯分类器分类函数
        
    Parameters:
        vec2Classify - 待分类的词条数组
        p0Vec - 侮辱类的条件概率数组
        p1Vec - 非侮辱类的条件概率数组
        pClass1 - 文档属于侮辱类的概率
        
    Returns:
        0 - 属于非侮辱类
        1 - 属于侮辱类
    """
    def classifyNB(vec2Classify, p0Vec, p1Vec, pClass1):
        # 对应元素相乘
        # p1 = reduce(lambda x,y:x*y, vec2Classify * p1Vec) * pClass1
        # p0 = reduce(lambda x,y:x*y, vec2Classify * p0Vec) * (1.0 - pClass1)
        # 对应元素相乘，logA*B = logA + logB所以这里是累加
        p1 = sum(vec2Classify * p1Vec) + np.log(pClass1)
        p0 = sum(vec2Classify * p0Vec) + np.log(1.0 - pClass1)
        # print('p0:', p0)
        # print('p1:', p1)
        if p1 > p0:
            return 1
        else:
            return 0
    
    
    """
    Desc:
        测试朴素贝叶斯分类器
    Parameters:
        None
        
    Returns:
        None
    """
    def testingNB():
        # 创建实验样本
        listOPosts, listclasses = loadDataSet()
        # 创建词汇表,将输入文本中的不重复的单词进行提取组成单词向量
        myVocabList = createVocabList(listOPosts)
        trainMat = []
        for postinDoc in listOPosts:
            # 将实验样本向量化若postinDoc中的单词在myVocabList出现则将returnVec该位置的索引置1
            # 将6组数据list存储在trainMat中
            trainMat.append(setOfWords2Vec(myVocabList, postinDoc))
        # 训练朴素贝叶斯分类器
        p0V, p1V, pAb = trainNB0(np.array(trainMat), np.array(listclasses))
        # 测试样本1
        testEntry = ['love', 'my', 'dalmation']
        # 测试样本向量化返回这三个单词出现位置的索引
        thisDoc = np.array(setOfWords2Vec(myVocabList, testEntry))
        if classifyNB(thisDoc, p0V, p1V, pAb):
            # 执行分类并打印结果
            print(testEntry, '属于侮辱类')
        else:
            # 执行分类并打印结果
            print(testEntry, '属于非侮辱类')
        # 测试样本2
        testEntry = ['stupid', 'garbage']
        # 将实验样本向量化
        thisDoc = np.array(setOfWords2Vec(myVocabList, testEntry))
        if classifyNB(thisDoc, p0V, p1V, pAb):
            # 执行分类并打印结果
            print(testEntry, '属于侮辱类')
        else:
            # 执行分类并打印结果
            print(testEntry, '属于非侮辱类')

testingNB()
    '''
    ['love', 'my', 'dalmation'] 属于非侮辱类
    ['stupid', 'garbage'] 属于侮辱类
    '''

import re
    import numpy as np
    import random
    
    """
    Desc:
        接受一个大字符串并将其解析为字符串列表
        
    Parameters:
        None
        
    Returns:
        None
    """
    def textParse(bigString):
        # 用特殊符号作为切分标志进行字符串切分，即非字母、非数字
        # \W* 0个或多个非字母数字或下划线字符（等价于[^a-zA-Z0-9_]）
        listOfTockens = re.split(r'\W*', bigString)
        # 除了单个字母，例如大写I，其他单词变成小写，去掉少于两个字符的字符串
        return [tok.lower() for tok in listOfTockens if len(tok) > 2]
    
    
    """
    Desc:
        将切分的实验样本词条整理成不重复的词条列表，也就是词汇表
        
    Parameters:
        dataSet - 整理的样本数据集
        
    Returns:
        vocabSet - 返回不重复的词条列表，也就是词汇表
    """
    def createVocabList(dataSet):
        # 创建一个空的不重复列表
        # set是一个无序且不重复的元素集合
        vocabSet = set([])
        for document in dataSet:
            # 取并集
            vocabSet = vocabSet | set(document)
        return list(vocabSet)
    
    
    """
    Desc:
        根据vocabList词汇表，将inputSet向量化，向量的每个元素为1或0
        
    Parameters:
        vocabList - createVocabList返回的列表
        inputSet - 切分的词条列表
        
    Returns:
        returnVec - 文档向量，词集模型
    """
    def setOfWords2Vec(vocabList, inputSet):
        # 创建一个其中所含元素都为0的向量
        returnVec = [0] * len(vocabList)
        # 遍历每个词条
        for word in inputSet:
            if word in vocabList:
                # 如果词条存在于词汇表中，则置1
                # index返回word出现在vocabList中的索引
                # 若这里改为+=则就是基于词袋的模型，遇到一个单词会增加单词向量中德对应值
                returnVec[vocabList.index(word)] = 1
            else:
                print("the word: %s is not in my Vocabulary" % word)
        # 返回文档向量
        return returnVec
    
    
    """
    Desc:
        根据vocabList词汇表，构造词袋模型
        
    Parameters:
        vocabList - createVocabList返回的列表
        inputSet - 切分的词条列表
        
    Returns:
        returnVec - 文档向量，词袋模型
    """
    def setOfWords2Vec(vocabList, inputSet):
        # 创建一个其中所含元素都为0的向量
        returnVec = [0] * len(vocabList)
        # 遍历每个词条
        for word in inputSet:
            if word in vocabList:
                # 如果词条存在于词汇表中，则置1
                # index返回word出现在vocabList中的索引
                # 若这里改为+=则就是基于词袋的模型，遇到一个单词会增加单词向量中德对应值
                returnVec[vocabList.index(word)] += 1
            else:
                print("the word: %s is not in my Vocabulary" % word)
        # 返回文档向量
        return returnVec
    
    
    """
    Desc:
        朴素贝叶斯分类器训练函数
        
    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)
        # 创建numpy.zeros数组，词条出现数初始化为0
        # p0Num = np.zeros(numWords)
        # p1Num = np.zeros(numWords)
        # 创建numpy.ones数组，词条出现数初始化为1,拉普拉斯平滑
        p0Num = np.ones(numWords)
        p1Num = np.ones(numWords)
        # 分母初始化为0
        # p0Denom = 0.0
        # p1Denom = 0.0
        # 分母初始化为2，拉普拉斯平滑
        p0Denom = 2.0
        p1Denom = 2.0
        for i in range(numTrainDocs):
            # 统计属于侮辱类的条件概率所需的数据，即P(w0|1),P(w1|1),P(w2|1)...
            if trainCategory[i] == 1:
                # 统计所有侮辱类文档中每个单词出现的个数
                p1Num += trainMatrix[i]
                # 统计一共出现的侮辱单词的个数
                p1Denom += sum(trainMatrix[i])
            # 统计属于非侮辱类的条件概率所需的数据，即P(w0|0),P(w1|0),P(w2|0)...
            else:
                # 统计所有非侮辱类文档中每个单词出现的个数
                p0Num += trainMatrix[i]
                # 统计一共出现的非侮辱单词的个数
                p0Denom += sum(trainMatrix[i])
        # 每个侮辱类单词分别出现的概率
        # p1Vect = p1Num / p1Denom
        # 取对数，防止下溢出
        p1Vect = np.log(p1Num / p1Denom)
        # 每个非侮辱类单词分别出现的概率
        # p0Vect = p0Num / p0Denom
        # 取对数，防止下溢出
        p0Vect = np.log(p0Num / p0Denom)
        # 返回属于侮辱类的条件概率数组、属于非侮辱类的条件概率数组、文档属于侮辱类的概率
        return p0Vect, p1Vect, pAbusive
    
    
    """
    Desc:
        朴素贝叶斯分类器分类函数
        
    Parameters:
        vec2Classify - 待分类的词条数组
        p0Vec - 侮辱类的条件概率数组
        p1Vec - 非侮辱类的条件概率数组
        pClass1 - 文档属于侮辱类的概率
        
    Returns:
        0 - 属于非侮辱类
        1 - 属于侮辱类
    """
    def classifyNB(vec2Classify, p0Vec, p1Vec, pClass1):
        # 对应元素相乘
        # p1 = reduce(lambda x,y:x*y, vec2Classify * p1Vec) * pClass1
        # p0 = reduce(lambda x,y:x*y, vec2Classify * p0Vec) * (1.0 - pClass1)
        # 对应元素相乘，logA*B = logA + logB所以这里是累加
        p1 = sum(vec2Classify * p1Vec) + np.log(pClass1)
        p0 = sum(vec2Classify * p0Vec) + np.log(1.0 - pClass1)
        # print('p0:', p0)
        # print('p1:', p1)
        if p1 > p0:
            return 1
        else:
            return 0
    
    
    """
    Desc:
        测试朴素贝叶斯分类器
        
    Parameters:
        None
        
    Returns:
        None
    """
    def spamTest():
        docList = []
        classList = []
        fullText = []
        # 遍历25个txt文件
        for i in range(1, 26):
            # 读取每个垃圾邮件，并以字符串转换成字符串列表
            wordList = textParse(open('email/spam/%d.txt' % i, 'r').read())
            docList.append(wordList)
            fullText.append(wordList)
            # 标记垃圾邮件，1表示垃圾文件
            classList.append(1)
            # 读取每个非垃圾邮件，并以字符串转换成字符串列表
            wordList = textParse(open('email/ham/%d.txt' % i, 'r').read())
            docList.append(wordList)
            fullText.append(wordList)
            # 标记非垃圾邮件，0表示非垃圾文件
            classList.append(0)
        # 创建词汇表，不重复
        vocabList = createVocabList(docList)
        # 创建存储训练集的索引值的列表和测试集的索引值的列表
        trainingSet = list(range(50))
        testSet = []
        # 从50个邮件中，随机挑选出40个作为训练集，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.append(setOfWords2Vec(vocabList, docList[docIndex]))
            # 将类别添加到训练集类别标签向量中
            trainClasses.append(classList[docIndex])
        # 训练朴素贝叶斯模型
        p0V, p1V, pSpam = trainNB0(np.array(trainMat), np.array(trainClasses))
        # 错误分类计数
        errorCount = 0
        # 遍历测试集
        for docIndex in testSet:
            # 测试集的词集模型
            wordVector = setOfWords2Vec(vocabList, docList[docIndex])
            # 如果分类错误
            if classifyNB(np.array(wordVector), p0V, p1V, pSpam) != classList[docIndex]:
                # 错误计数器加1
                errorCount += 1
                print("分类错误的测试集：", docList[docIndex])
        print("错误率：%.2f%%" % (float(errorCount) / len(testSet) * 100))

spamTest()
    '''
    分类错误的测试集： []
    分类错误的测试集： []
    分类错误的测试集： []
    分类错误的测试集： []
    分类错误的测试集： []
    错误率：50.00%
    '''

Jieba分词练习

from sklearn.naive_bayes import MultinomialNB
    import matplotlib.pyplot as plt
    import os
    import random
    import jieba
    
    """
    Desc:
        中文文本处理将文件夹内部的所有txt文档分词并存储在data_list中，将txt上一级文件夹名称存储在class_list中
        
    Parameters:
        folder_path - 文本存放的路径
        test_size - 测试集占比，默认占所有数据集的20%
        
    Returns:
        all_words_list - 按词频降序排序的训练集列表
        train_data_list - 训练集列表
        test_data_list - 测试集列表
        train_class_list - 训练集标签列表
        test_class_list - 测试集标签列表
    """
    def TextProcessing(folder_path, test_size=0.2):
        # 查看folder_path下的文件
        # os.listdir(path)方法用于返回指定的文件夹包含的文件或文件夹的名字列表。这个列表以字母顺序。
        # 它不包括'.'和'..'即使它在文件夹中。
        folder_list = os.listdir(folder_path)
        # 数据集数据
        data_list = []
        # 数据集类别
        class_list = []
        # 遍历每个子文件夹
        for folder in folder_list:
            # 根据子文件夹，生成新的路径
            # os.path.join路径名拼接即folder_path+folder从而生成新的路径，可以遍历每一个文件
            new_folder_path = os.path.join(folder_path, folder)
            # 存放子文件夹下的txt文件列表
            files = os.listdir(new_folder_path)
            j = 1
            # 遍历每个txt文件
            for file in files:
                # 每类txt样本数最多100个
                if j > 100:
                    break
                # 打开txt文件
                with open(os.path.join(new_folder_path, file), 'r', encoding='utf-8') as f:
                    # 读取txt文件内容
                    raw = f.read()
                # 精简模式，返回一个可迭代的generator
                # jieba.cut方法接受两个输入参数：1）第一个参数为需要分词的字符串 2）cut_all参数用来控制是否采用
                # 全模式
                word_cut = jieba.cut(raw, cut_all=False)
                # generator转换为list
                word_list = list(word_cut)
                # 存储经过分割以后的词语列表
                data_list.append(word_list)
                # 存储上一级文件夹名称
                class_list.append(folder)
                # 自增
                j += 1         
        # zip压缩合并，将数据与标签对应压缩
        # zip()函数用于将可迭代的对象作为参数，将对象中对应的元素打包成一个个元组，然后返回由这些元组组成的列表
        # 如果各个迭代器的元素个数不一致，则返回列表长度与最短对象相同，利用*号操作符，可以将元组解压为列表
        # python3中zip()返回一个对象，如需展示列表，需手动list()转换
        data_class_list = list(zip(data_list, class_list))
        # 将data_class_list乱序，shuffle()方法将序列或元组所有元素随机排序
        random.shuffle(data_class_list)
        # 训练集和测试集切分的索引值
        index = int(len(data_class_list) * test_size) + 1
        # 训练集
        train_list = data_class_list[index:]
        # 测试集
        test_list = data_class_list[:index]
        # 训练集解压缩为列表
        train_data_list, train_class_list = zip(*train_list)
        # 测试集解压缩为列表
        test_data_list, test_class_list = zip(*test_list)
        # 统计训练集词频
        all_words_dict = {
        }
        for word_list in train_data_list:
            for word in word_list:
                if word in all_words_dict.keys():
                    all_words_dict[word] += 1
                else:
                    # 拉普拉斯平滑
                    all_words_dict[word] = 1
        # 根据键的值倒序排序
        all_words_tuple_list = sorted(all_words_dict.items(), key = lambda f:f[1], reverse = True)
        # 字典解压缩为列表
        all_words_list, all_words_nums = zip(*all_words_tuple_list)
        # 转换成列表
        all_words_list = list(all_words_list)
        return all_words_list, train_data_list, test_data_list, train_class_list, test_class_list
    
    
    """
    Desc:
        读取文件里的内容，并去重
        
    Parameters:
        words_file - 文件路径
        
    Returns:
        words_set - 读取的内容的set集合
    """
    def MakeWordsSet(words_file):
        # set是一个无序且不重复的元素集合
        words_set = set()
        # 打开文件
        with open(words_file, 'r', encoding='utf-8') as f:
            # 一行一行读取
            for line in f.readlines():
                # 去掉每行两边的空字符
                word = line.strip()
                # 有文本，则添加到words_set中
                if len(word) > 0:
                    # 集合add方法：把要传入的元素作为一个整体添加到集合中
                    # 如add('python')即为‘python’
                    # 集合update方法：要把传入元素拆分，作为个体传入到集合中
                    # 如update('python')即为'p''y''t''h''o''n'
                    words_set.add(word)
        # 返回处理结果
        return words_set
    
    
    """
    Desc:
        文本特征选取
        
    Parameters:
        all_words_list - 训练集所有文本列表
        deleteN - 删除词频最高的deleteN个词
        stopwords_set - 指定的结束语
        
    Returns:
        feature_words - 特征集
    """
    def words_dict(all_words_list, deleteN, stopwords_set=set()):
        # 特征列表
        feature_words = []
        n = 1
        for t in range(deleteN, len(all_words_list), 1):
            # feature_words的维度为1000
            if n > 1000:
                break
            # 如果这个词不是数字，并且不是指定的结束语，并且单词长度大于1小于5，那么这个词就可以作为特征词
            if not all_words_list[t].isdigit() and all_words_list[t] not in stopwords_set and 1 < len(all_words_list[t]) < 5:
                feature_words.append(all_words_list[t])
            n += 1
        return feature_words
              
    
    """
    Desc:
        根据feature_words将文本向量化
        
    Parameters:
        train_data_list - 训练集
        test_data_list - 测试集
        feature_words - 特征集
        
    Returns:
        train_feature_list - 训练集向量化列表
        test_feature_list - 测试集向量化列表
    """
    def TextFeatures(train_data_list, test_data_list, feature_words):
        # 出现在特征集中，则置1
        def text_features(text, feature_words):
            # set是一个无序且不重复的元素集合
            text_words = set(text)
            features = [1 if word in text_words else 0 for word in feature_words]
            return features
        train_feature_list = [text_features(text, feature_words) for text in train_data_list]
        test_feature_list = [text_features(text, feature_words) for text in test_data_list]
        # 返回结果
        return train_feature_list, test_feature_list
    
    
    """
    Desc:
        新闻分类器
        
    Parameters:
        train_feature_list - 训练集向量化的特征文本
        test_feature_list - 测试集向量化的特征文本
        train_class_list - 训练集分类标签
        test_class_list - 测试集分类标签
        
    Returns:
        test_accuracy - 分类器精度
    """
    def TextClassifier(train_feature_list, test_feature_list, train_class_list, test_class_list):
        # fit(X,y) Fit Naive Bayes classifier according to X, y
        classifier = MultinomialNB().fit(train_feature_list, train_class_list)
        # score(X,y) Returns the mean accuracy on the given test data and labels
        test_accuracy = classifier.score(test_feature_list, test_class_list)
        return test_accuracy
    
    
    """
    Desc:
        main函数
        
    Parameters:
        None
        
    Returns:
        None
    """
    def main():
        # 文本预处理
        # 训练集存放地址
        folder_path = './SogouC/Sample'
        all_words_list, train_data_list, test_data_list, train_class_list, test_class_list = TextProcessing(folder_path, test_size=0.2)
        # print(all_words_list)
        # 生成stopwords_set
        stopwords_file = './stopwords_cn.txt'
        stopwords_set = MakeWordsSet(stopwords_file)
        # 词频出现前100的删除
        # feature_words = words_dict(all_words_list, 100, stopwords_set)
        # print(feature_words)
        test_accuracy_list = []
        # 0 20 40 60 ... 980
        deleteNs = range(0, 1000, 20)
        for deleteN in deleteNs:
            feature_words = words_dict(all_words_list, deleteN, stopwords_set)
            train_feature_list, test_feature_list = TextFeatures(train_data_list, test_data_list, feature_words)
            test_accuracy = TextClassifier(train_feature_list, test_feature_list, train_class_list, test_class_list)
            test_accuracy_list.append(test_accuracy)
        plt.figure()
        plt.plot(deleteNs, test_accuracy_list)
        plt.title('Relationship of deleteNs and test_accuracy')
        plt.xlabel('deleteNs')
        plt.ylabel('test_accurecy')
        plt.show()
        # 经过测试450效果比较好
        feature_words = words_dict(all_words_list, 450, stopwords_set)
        train_feature_list, test_feature_list = TextFeatures(train_data_list, test_data_list, feature_words)
        test_accuracy = TextClassifier(train_feature_list, test_feature_list, train_class_list, test_class_list)
        test_accuracy_list.append(test_accuracy)
        ave = sum(test_accuracy_list) / len(test_accuracy_list)
        print('当删掉前450个高频词分类精度为：%.5f' % ave)

main()

Building prefix dict from the default dictionary …  
Dumping model to file cache  
Loading model cost 0.704 seconds.  
Prefix dict has been built succesfully.  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTcyODQzMQ_size_16_color_FFFFFF_t_70]  
当删掉前450个高频词分类精度为：0.59856

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTcyODQzMQ_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/20191123223732468.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTcyODQzMQ==,size_16,color_FFFFFF,t_70