机器学习： 贝叶斯算法的应用

机器学习： 贝叶斯算法的应用

背景

数据集及源码

互联网经济蓬勃发展的背景下,食品经营模式发生了天翻地覆的变化,人们的消费习惯也悄然发生了转变。通过点击手机APP上自己喜欢的食品,

这些食品就能按时准确送达指定的区域，这就是当下最受学生和白领喜欢的外卖。然而随着其迅猛发展带来了一定的食品安全隐患，食品安全

事故的发生对消费者、外卖平台、食品商家和社会的危害性远远超出想象。

本课题旨在通过对O2O店铺评论的监测，加强对店铺的食品安全监管。

任务

本课题的数据为 2019 CCF大数据与计算智能大赛 提供的10000条对O2O店铺的评论文本训练数据，

分为与食品安全有关和与食品安全无关两个类别。需要根据训练集构造文本分类模型，预测2000条测试集中的评论是否与食品安全有关。

!pip install jieba

Requirement already satisfied: jieba in c:\programdata\anaconda3\lib\site-packages (0.39)

导入相关库

import pandas as pd
import jieba
import numpy as np
import re

1.数据预处理

(1)检查数据

datas = pd.read_csv('data/train.csv')

#读取前20条数据
datas.head(20)

	label comment
0	0\t一如既往地好吃，希望可以开到其他城市
1	0\t味道很不错，分量足，客人很多，满意
2	0\t下雨天来的，没有想象中那么火爆。环境非常干净，古色古香的，我自己也是个做服务行业的，我...
3	0\t真心不好吃 基本上没得好多味道
4	0\t少送一个牛肉汉堡 而且也不好吃 特别是鸡肉卷 **都不想评论了 谁买谁知道
5	0\t用美团，图打折。
6	0\t好难吃水煮鸡杂呀
7	0\t环境很好，服务很热情，味道非常好，鱼也很新鲜，我和儿子吃的好饱，包子和饺子很好吃哟，
8	0\t一如既往的好吃，个人更喜欢吃全翅
9	0\t四个就把我吃饱了……阔以
10	0\t蛋糕很好吃，送货及时，服务一流啊，下次有机会继续买。
11	0\t肉不好吃#脆香鸡排煲仔饭+半卤蛋##秘制小炒肉煲仔饭+半卤蛋#太辣#功夫烤鸡腿肉煲仔饭...
12	1\t恶心，不想说了，喝嘴里嚼两下觉得口感不对，吐出来就是只小蟑螂，关键是我还嚼了两口，昨天...
13	0\t巨难吃，一个咸一个酸
14	0\t价格实惠，服务态度很好，分量超足，鸭爪入口即化，软糯，很入味，超辣，推荐！
15	0\t喜欢这个地方，菜品多，味道也不错，最好点个鸳鸯锅，锅底也是20元
16	0\t真的很不错，吃了俩次了，朋友从外地来，特意带她们来吃的，他们回去吃东西都觉得没味，还是...
17	0\t很好吃，强力推荐，香菜牛肉果然是招牌菜名不虚传
18	0\t味道不错，份量不足
19	1\t真的无语，上两次还觉得可以，今天这个菠萝包里头奶油都臭了，完全不能吃

(2)数据处理

 #获得停用词表
def getStopWords():
    stopList=[]
    for line in open("data/中文停用词表.txt"):
        stopList.append(line[:len(line)-1])
    return stopList;

def loadDataSet(data):
    '''
    数据预处理，去掉特殊字符和不关键的字词
    过滤评论label：  涉及食品安全：1     非食品安全：0
    '''
    comment = []
    label = []
    include_list = getStopWords()
    character = '[a-zA-Z2-9’!"#$%&\'()*+,-./:;<=>?@，。?★、…【】《》？～“”‘’！❤️[\\]^_`{|}~\s]+'
    for line in data:
        lines = str(line).strip().strip("['']")
        #去掉特殊字符
        lines = re.sub(character, "", lines)
        #去掉非关键词
        for key in include_list:
            lines = lines.replace(key,'')
        lines = lines.split('\\')
        if((lines[0] is "0") or (lines[0] is "1")):
            label.append(int(lines[0]))
        else:
            label.append(0)
        comment.append(lines[1])
    class_comment = [[0 for i in range(0)] for j in range(len(comment))]
    #数据内容进行jieba分词
    i = 0
    for line in comment:
        line = list(jieba.cut_for_search(str(line)))
        for lines in line:
            class_comment[i].append(lines)
        i=i+1
    return class_comment, label

#获取测试文件
def loadTestDataSet(data):
    comment = []
    include_list = getStopWords()
    character = '[a-zA-Z2-9’!"#$%&\'()*+,-./:;<=>?@，。?★、…【】《》？～“”‘’！❤️[\\]^_`{|}~\s]+'
    for line in data:
        lines = str(line).strip().strip("['']")
        #去掉特殊字符
        lines = re.sub(character, "", lines)
        #去掉非关键词
        for key in include_list:
            lines = lines.replace(key,'')
        comment.append(lines)
    class_comment = [[0 for i in range(0)] for j in range(len(comment))]
    #数据内容进行jieba分词
    i = 0
    for line in comment:
        line = list(jieba.cut_for_search(str(line)))
        for lines in line:
            class_comment[i].append(lines)
        i=i+1
    return comment

2.贝叶斯算法

# 创建一个包含在所有文档中出现的不重复词的列表
def createVocabList(dataSet):
    vocabSet = set([])      # 创建一个空集
    for document in dataSet:
        vocabSet = vocabSet | set(document)   # 创建两个集合的并集
    return list(vocabSet)

# 将文档词条转换成词向量
def setOfWords2Vec(vocabList, inputSet):
    returnVec = [0]*len(vocabList)        # 创建一个其中所含元素都为0的向量
    for word in inputSet:
        if word in vocabList:
            # returnVec[vocabList.index(word)] = 1     # index函数在字符串里找到字符第一次出现的位置  词集模型
            returnVec[vocabList.index(word)] += 1      # 文档的词袋模型    每个单词可以出现多次
        else: 
            pass
            #print ("the word: %s is not in my Vocabulary!" % word)
    return returnVec

# 朴素贝叶斯分类器训练函数   从词向量计算概率
def trainNB0(trainMatrix, trainCategory):
    numTrainDocs = len(trainMatrix)
    numWords = len(trainMatrix[0])
    pAbusive = sum(trainCategory)/float(numTrainDocs)
    # p0Num = zeros(numWords); p1Num = zeros(numWords)
    # p0Denom = 0.0; p1Denom = 0.0
    p0Num = np.ones(numWords);   # 避免一个概率值为0,最后的乘积也为0
    p1Num = np.ones(numWords);   # 用来统计两类数据中，各词的词频
    p0Denom = 2.0;  # 用于统计0类中的总数
    p1Denom = 2.0  # 用于统计1类中的总数
    for i in range(numTrainDocs):
        if trainCategory[i] == 1:
            p1Num += trainMatrix[i]
            p1Denom += sum(trainMatrix[i])
        else:
            p0Num += trainMatrix[i]
            p0Denom += sum(trainMatrix[i])
            # p1Vect = p1Num / p1Denom
            # p0Vect = p0Num / p0Denom
    p1Vect = np.log(p1Num / p1Denom)    # 在类1中，每个次的发生概率
    p0Vect = np.log(p0Num / p0Denom)      # 避免下溢出或者浮点数舍入导致的错误   下溢出是由太多很小的数相乘得到的
    return p0Vect, p1Vect, pAbusive

# 朴素贝叶斯分类器
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

3.训练测试

def testingNB():
    df=pd.read_csv('data/train.csv') 
    data = np.array(df)
    listOPosts, listClasses = loadDataSet(data[:5000])
    myVocabList = createVocabList(listOPosts)
    trainMat = []
    test_label_list = []
    for postinDoc in listOPosts:
        trainMat.append(setOfWords2Vec(myVocabList, postinDoc))
    p0V, p1V, pAb = trainNB0(np.array(trainMat), np.array(listClasses))
    testEntry_list,test_label = loadDataSet(data[5000:])
    for testEntry in  testEntry_list:
        thisDoc = np.array(setOfWords2Vec(myVocabList, testEntry))
        test_label_list.append(classifyNB(thisDoc, p0V, p1V, pAb))
#         print (testEntry, 'classified as: ', classifyNB(thisDoc, p0V, p1V, pAb))

    i = 0
    count = 0
    for label in test_label:
        if label is test_label_list[i]:
            count=count + 1
    print("正确率:",count/len(test_label))

# 调用测试方法
testingNB()

Building prefix dict from the default dictionary ...
Dumping model to file cache C:\Users\ADMINI~1\AppData\Local\Temp\2\jieba.cache
Loading model cost 1.492 seconds.
Prefix dict has been built succesfully.


正确率: 0.8438

4.预测

def forecast():
    df=pd.read_csv('data/train.csv') 
    data = np.array(df)
    listOPosts, listClasses = loadDataSet(data)
    myVocabList = createVocabList(listOPosts)
    trainMat = []
    print("训练。。。。")
    for postinDoc in listOPosts:
        trainMat.append(setOfWords2Vec(myVocabList, postinDoc))
    p0V, p1V, pAb = trainNB0(np.array(trainMat), np.array(listClasses))
    print("预测。。。。")
    test_label_list = []
    test_df = pd.read_csv('data/test_new.csv') 
    test_data = np.array(test_df["comment"])
    test_id = list(np.array(test_df["id"]))
    comment = loadTestDataSet(test_data)
    for testEntry in  comment:
        thisDoc = np.array(setOfWords2Vec(myVocabList, testEntry))
        test_label_list.append(classifyNB(thisDoc, p0V, p1V, pAb))
    #写入文件保存
    print("保存数据。。。。")
    dataframe = pd.DataFrame({'id':test_id ,'label':test_label_list})
    #将DataFrame存储为csv,index表示是否显示行名，default=True
    dataframe.to_csv("forecast/forecast.csv",index=False,sep=',')

forecast()

训练。。。。
预测。。。。
保存数据。。。。

预测结果前10项

result = pd.read_csv('forecast/forecast.csv')
result.head(10)

	id	label
0	0011f384-9e54-4fb4-a272-330a6cab6804	0
1	00223e4f-47e1-4fc8-9657-06444a7de9a5	1
2	00225350-c169-435c-84cf-970068df5b12	0
3	00a3190c-90c1-44c3-b809-7a9b1314cd27	0
4	00b3f76e-fda3-42cd-8884-25e03a5dba64	0
5	00b6d1c7-2f3e-4124-a5ba-5f4c4342bc94	1
6	00fb0c72-569a-4cf3-8273-b602564d64ba	1
7	0136d22b-d1a5-45af-bf47-fd5f95863011	1
8	01662368-434b-4cf9-a885-0855c884cdf1	1
9	01876c3f-d9c5-4ddf-83d1-045830755138	0