朴素贝叶斯----评论情感分析系统

文章目录

2022/12/17更新，由于很多小伙伴需要数据集与代码，我已上传至github，请点击此处获得。

前言

近期学校实验室有一个任务，要求爬取大量评论数据，自己构建机器学习模型并训练数据集，对评论进行情感的分析，即好评或差评。

刚好前天学到了朴素贝叶斯定理, 便根据该定理构建模型，训练数据集，评估模型，并完成了评论情感的分析。

以下是具体实现步骤

Step1: 爬取京东评论，作为模型数据集

爬取10个京东商品的评论信息，每个商品爬取1000条，其中好评信息爬取6000条，差评信息爬取4000条。

作为本次评论情感分析的数据集。

测试爬虫

首先测试下爬虫效果，可以爬取评论信息

import requests
import json


#获取评论请求地址
url = 'https://club.jd.com/comment/productPageComments.action'

#请求参数
params = {
    'callback': 'fetchJSON_comment98',
    'productId': '100021771660',
    'score': '1',            #类型代表差评
    'sortType': '5',         #默认排序
    'page': '99',            #第99页数据
    'pageSize': '10',
    'isShadowSku': '0',
    'fold': '1',
}

#请求头参数，反反爬策略 UA 伪装
headers = {
    'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/104.0.0.0 Safari/537.36'
}

#获取响应，并分析响应内容
response = requests.get(url=url, params=params, headers=headers)

#拆分京东返回的响应数据，得到json类型数据
data_json = response.text.replace('fetchJSON_comment98(', '')[:-2]

#将json字符串加载为 python的对象中
data = json.loads(data_json)

bad_comments = []

for comment in data['comments']:
    
    #生成每条评论以及它的标签, 0代表好评, 1代表差评
    comments = [comment['content'].replace('\n', ''), '0']
    
    bad_comments.append(comments)

print(bad_comments)


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45

运行结果

   [['1.买完没多久就降价600，很无语2.电脑开机经常出现wifi连不上的问题', '0'], 
   ['刚买的，第二次使用就开不了机了，怀疑买的是假货，要求京东给出说法', '0'], 
   ['一分都不想给啊 买来就做个账 转转账 卡的要死', '0'],
   ['用了2个星期了，第1个星期还没事，第2个星期动不动就开不了机。', '0'],
   ['非常垃圾的电脑，这个价位配置这么低，新机子就卡的要死，强烈要求退货', '0'],
   ['买了不到2个月就开不开机了 找客服 没有搭理 真是失望至极！', '0'], 
   ['差评 垃圾机 老是卡顿', '0'], ['重装系统office2021会直接消失 需要重新购买 体验非常差', '0'],
   ['刚买的居然发现硬盘被使用了九天，插口也有拔插的痕迹，漆都掉了。严重怀疑是上一个买家用了七天退货产品。', '0'], 
   ['京东物流太差了，包装箱破损严重，明显是重摔造成的，幸亏里面的货没有损伤。', '0']]

1
2
3
4
5
6
7
8
9
10

爬取6000条好评信息作为数据集，并存储为CSV文件

商品链接分别为：(每个商品爬取1000条评论)

Apple MacBook Pro 13.3 八核M1芯片 8G 256G SSD 深空灰笔记本电脑轻薄本 MYD82CH/A

联想笔记本电脑小新Pro14 英特尔Evo平台 14英寸游戏轻薄本(标压i5 16G 512G 2.8K 90Hz护眼屏)全面屏办公本

华为笔记本电脑MateBook D 14 2022款 14英寸 11代酷睿 i5 16G+512G 锐炬显卡轻薄本/护眼全面屏银

联想ThinkBook 14+ 英特尔酷睿i5 笔记本电脑全新2022款 14英寸标压轻薄本i5-12500H 16G 512G 2.8K 90Hz

荣耀MagicBook 16 16.1英寸高性能标压轻薄笔记本电脑(R7-5800H 16+512G 144Hz高刷)冰河银

惠普（HP）笔记本电脑星14进阶版高端pro轻薄本超薄商用办公游戏手提学生女超极本旗舰店官网初恋粉：【背光键盘版-新11代进阶丨2022款】新i5-1155G7/16G/512G/高72%

由于水平原因，总是被反爬虫，所以本段代码需要执行6次(差评需要执行4次)，来爬取6000条信息，每次执行需要更换以下ids中的商品id。

import requests
import json
import time
import csv


#获取评论请求地址
url = 'https://club.jd.com/comment/productPageComments.action'


#请求头参数，反反爬策略 UA 伪装
headers = {
    'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/104.0.0.0 Safari/537.36'
}

#存放每个商品的id，理论上行得通，实际上行不通，因为反爬策略所以需要多次执行
ids = ['100009464821','100014546493','100016960357','100020078921', '100014373845','32421759213']

#用于存放所有好评信息的数据
good_comments = []

for i in range(100):
    #请求参数
    params = {
        'callback': 'fetchJSON_comment98',
        'productId': '32421759213',          #代表产品的 id 
        'score': '3',                         #score = 3 代表均为好评信息
        'sortType': '5',                      #排序方式，采用默认排序
        'page': str(i),                       #循环爬取每一页的评论信息
        'pageSize': '10',
        'isShadowSku': '0',
        'fold': '1',
    }
    
    #获取响应，并分析响应内容
    response = requests.get(url = url, params=params, headers=headers)

    #拆分京东返回的响应数据，得到json类型数据
    data_json = response.text.replace('fetchJSON_comment98(', '')[:-2]

    #将json字符串加载为 python的对象中
    data = json.loads(data_json)
    
    #设置标签为 0， 代表好评
    target = '0'
    
    for comment in data['comments']:
        
        #对评论数据稍作处理。 去除一些制表符、回车符、包括csv文件分组的','逗号
        comment_data = comment['content'].replace('\n', '，').replace(',', '，').replace('…','').replace(' ','')
        
        #生成每条评论以及它的标签, 0代表好评, 1代表差评
        comments = [comment_data, target]

        good_comments.append(comments)

    print(i+1)
    #延迟爬虫，避免反爬
    time.sleep(2)


#以 写 的方式打开csv文件，并写入好评信息
with open('./datasets/comments.csv', 'a+', encoding='UTF-8', newline='') as fp:
    writer = csv.writer(fp)
    writer.writerows(good_comments)
    
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66

爬取4000条差评信息作为数据集，并存储为CSV文件

商品链接分别为：(每个商品爬取1000条评论)

联想笔记本电脑小新Pro14 英特尔Evo平台 14英寸游戏轻薄本(标压i5 16G 512G 2.8K 90Hz护眼屏)全面屏办公本

华为笔记本电脑MateBook D 14 2022款 14英寸 11代酷睿 i5 16G+512G 锐炬显卡轻薄本/护眼全面屏银

联想笔记本电脑小新Air14 英特尔酷睿i5 14英寸轻薄本(i5 16G 512G 高色域大电池)银全面屏商务办公本

联想笔记本电脑小新Pro16 16英寸游戏轻薄本(8核标压R7-5800H 16G 512G RTX3050 2.5K 120Hz)高性能商务办公

#用于存放所有差评信息的数据
bad_comments = []

for i in range(3):
    
    #请求参数
    params = {
        'callback': 'fetchJSON_comment98',
        'productId': '100021771660',
        'score': '1',                         #score = 1 代表均为差评信息
        'sortType': '5',
        'page': str(i),                       #循环爬取每一页的评论信息
        'pageSize': '10',
        'isShadowSku': '0',
        'fold': '1',
    }
    
    #获取响应，并分析响应内容
    response = requests.get(url = url, params=params, headers=headers)

    #拆分京东返回的响应数据，得到json类型数据
    data_json = response.text.replace('fetchJSON_comment98(', '')[:-2]

    #将json字符串加载为 python的对象中
    data = json.loads(data_json)
    
    #设置标签为 1， 代表差评
    target = '1'
    
    for comment in data['comments']:
        
        #对评论数据稍作处理， 去除'\n'换行符和 csv文件分隔符 ',' 逗号
        comment_data = comment['content'].replace('\n', '，').replace(',', '，').replace('…','').replace(' ','')
        
        #生成每条评论以及它的标签, 0代表好评, 1代表差评
        comments = [comment_data, target]

        bad_comments.append(comments)

    
    print(i+1)
    #延迟爬虫，避免反爬
    time.sleep(5)


#以 追加 的方式打开csv文件，并写入好评信息
with open('./datasets/comments.csv', 'a+', encoding='UTF-8', newline='') as fp:
    writer = csv.writer(fp)
    writer.writerows(bad_comments)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49

Step2: 读取数据集

import numpy as np

#用来存放评论的数据集
dataset = None

#打开文件，并将所有评论信息读取至数据集
with open('./datasets/comments.csv', 'r', encoding='UTF-8') as fp:
    reader = csv.reader(fp)
    
    dataset = np.array([comment for comment in reader])

#输出数据集的形状
print(dataset.shape)
1
2
3
4
5
6
7
8
9
10
11
12
13

(10000, 2)
1

可见，该数据集一共包含10000条数据，包含评论信息、评论类别信息。

Step3: 数据预处理(分词、去除停用词、建立词典)

import jieba

dictionary = []            #定义词典
stop_words = []            #定义停用词表
clear_dataset = []         #定义清洗后的数据集

#读取停用词表，并以列表的方式存入stop_words中
with open('./file/cn-stopwords.txt', 'r', encoding='UTF-8') as fp:
    stop_words = fp.read().split('\n')

for comment in dataset:
    words = []      #存放切词后、去除停用词后的句子词组
    
    #使用jieba对评论进行分词
    for word in jieba.lcut(comment[0]):
        
        #若切出来的词语 不属于停用词表， 加入词组中
        if word not in stop_words:
            words.append(word)

        #向词典中加入所有未加入的词语
        if word not in dictionary:
            dictionary.append(word)
        
    #追加句子词组和对应的标志
    clear_dataset.append([words,comment[1]])


#输出词典的长度
print(len(dictionary))


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

12747
1

Step4: 评论语句转化为向量

from sklearn.model_selection import train_test_split


X = []                                     #存放word2vec后的评论向量
y = [y[1] for y in clear_dataset]         #存放每条评论的结果

#遍历所有清洗后的评论数据，并将所有评论文本信息转化为向量信息
for clear_data in clear_dataset:
    
    #评论信息列表赋值为sentence
    sentence = clear_data[0]
    
    #首先将每个评论分词列表设置为 (1,5023)的向量，每个向量值为1
    #一个句子转化为一个向量
    word_2_vec = np.zeros(len(dictionary))
    
    
    #遍历字典，将所有评论分词列表 转化为 向量列表 (超重要!!!)
    for word in sentence:
        
        #如果word存在于字典中
        if word in dictionary:
            
            #找到该词在字典中的位置
            loc = dictionary.index(word)
            
            #此句子对照向量的该位置加1
            word_2_vec[loc] += 1 

    #X，即输入句子的特征向量列表，追加新句子向量
    X.append(word_2_vec)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

Step5: 拆分数据集----训练集、测试集

训练集用来训练构建的模型，测试集用来测试模型的性能

X = np.array(X)               #转化为numpy数组，X作为输入项，即评论生成的向量
y = np.array(y)               #转化为numpy数组，X作为输出项，即评论的类别

#X_train，y_train为训练集数据
#X_test,y_test为测试集数据
X_train, X_test, y_train, y_test = train_test_split(X, y)            #使用sklearn库的随即切分函数，将X、y划分为训练集与测试集


#分别输出训练集的 X, y形状， 测试集的X, y的形状
print(X_train.shape)
print(y_train.shape)
print(X_test.shape)
print(y_test.shape)
1
2
3
4
5
6
7
8
9
10
11
12
13

(7500, 12747)
(7500,)
(2500, 12747)
(2500,)
1
2
3
4

Step6: 以朴素贝叶斯算法构建模型、训练模型

这一段代码可能是最难理解的一段代码，因为此处涉及到朴素贝叶斯模型算法。

注意观察朴素贝叶斯算法:

$\frac{P(B|A)P(A)}{P(B)}$

即为:

$\frac{P(特征|类别)P(类别)}{P(特征)}$

此时问题转化为了求解:

$P (特征 ∣ 类别)$
$P (类别)$
$P (特征)$

由于朴素贝叶斯的设定每个特征之间都是独立的,可以推出:

$P (特征 ∣ 类别) = P (特征 1∣ 类别) * P (特征 2∣ 类别) * P (特征 3∣ 类别) * ... * P (特征 n ∣ 类别)$

那么, 我们可以依次求出 P(特征1|类别)、P(特征2|类别)、P(特征3|类别)…P(特征n|类别)，即

$\frac{此类别发生时特征i出现次数}{类别次数(好评/差评次数)}$

也可得出:

$\frac{某类别次数}{好评、差评之和}$

如， $\frac{好评次数}{好评、差评之和}$

通过全概率公式，可知(本情景下仅两种类别)

$P (特征) = P (类别 1) * P (特征 ∣ 类别 1) + P (类别 2) * P (特征 ∣ 类别 2)$

我们可以想象下，无论求好评概率或者差评概率，最终都要除以 P(特征), P(特征)对于此两种概率是无变化的，所以我们可以将其忽略，都不除，直接比较。

此时，我们只需要求出所有 P(特征i|类别)，到时候便可方便使用贝叶斯公式计算, 代入到代码，可得

good_pro, 即P(好评), 代表好评的概率

good_num, 即好评次数

bad_num，即差评次数

good_vec, 作为一个好评向量，记录每次好评时，每个词语出现的次数

bad_vec, 作为一个差评向量，记录每次差评时, 每个词语出现的次数

good_vec_trained = good_vec / good_num，即用于存放所有的 P(特征i|好评)向量，每个值代表一个概率

bad_vec_trained = bad_vec / bad_num, 即用于存放所有的 P(特征i|差评)向量，每个值代表一个概率

最后套用朴素贝叶斯公式，即可得出每条评论的情感，好评或差评。

len_dic = len(dictionary)               #词典的长度，即所有词的长度

good_pro = np.sum(y_train == '0')/len(X_train)     #好评率

good_num = 0                    #好评的次数
bad_num = 0                     #差评的次数


#初始化之所以为 1，是防止P(特征i|类别)中某个为0，导致连乘积为0
good_vec = np.ones(len_dic)             #向量组，每个值(词语)代表好评的次数,初始化全为1
bad_vec = np.ones(len_dic)              #向量组，每个值(词语)代表差评的次数，初始化全为1


for i in range(len(X_train)):

    #代表的是好评
    if y_train[i] == '0':
        good_vec += X_train[i]                #把该评论词语代表的向量,累加到good_vec
        good_num += 1                   #好评次数增加
    
    #否则是差评
    else:
        bad_vec += X_train[i]                #把该评论词语代表的向量,累加到bad_vec
        bad_num += 1                    #差评次数增加


#取log的原因有二：1、拉普拉斯平滑，防止太小的结果乘积造成下溢。2、log(连乘积)可以转化为 log累加
good_vec_trained = np.log(good_vec/good_num)          #用于存放所有的 P(特征i|好评)向量，每个值代表一个概率
bad_vec_trained = np.log(bad_vec/bad_num)             #用于存放所有的 P(特征i|差评)向量，每个值代表一个概率

print('good_pro is: {}'.format(good_pro))
print('good_vec_trained is: {}'.format(good_vec_trained))
print('bad_vec_trained is: {}'.format(bad_vec_trained))
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

good_pro is: 0.5993333333333334
good_vec_trained is: [-4.19121324 -8.41072095 -5.9258143  ... -8.41072095 -8.41072095
 -8.41072095]
bad_vec_trained is: [-3.78852514 -8.00803285 -7.31488567 ... -7.31488567 -7.31488567
 -7.31488567]
1
2
3
4
5

理论上讲此处 good_pro 应为 0.6，指的是好评概率，但可能获取的数据有些纰漏，导致good_pro为 0.599333，对于模型并无大碍。

Step7: 评估模型

训练完模型，得到good_vec_trained、bad_vec_trained、good_pro后，就可以直接根据贝叶斯公式计算好评或者差评的概率

因为使用了拉普拉斯平滑，所以贝叶斯公式的分子项:

$L o g (P (特征 ∣ 类别) P (类别)) = L o g (P (特征 1∣ 类别) * P (特征 2∣ 类别) * P (特征 3∣ 类别) * ... * P (特征 n ∣ 类别)) + L o g (P (类别))$

可转化为:

$L o g (P (特征 ∣ 类别) P (类别))) = L o g (P (特征 1∣ 类别)) + L o g (P (特征 2∣ 类别)) + ... + L o g (P (特征 n ∣ 类别)) + L o g (P (类别))$

其中，X_test[i] 表示一个评论语句转化成的向量。

例如，

P(特征|好评) = X_test[i] * good_vec_trained，两个向量数组相乘，列表内的值，两两相乘，最后得到结果

以下是对测试集，未训练的数据进行测试，评估模型的性能

success_count = 0

for i in range(2500):
    
    #代入朴素贝叶斯公式
    
    #评论好评的概率
    good_pro_pre = np.sum(X_test[i] * good_vec_trained) + np.log(good_pro)
    
    #评论差评的概率
    bad_pro_pre = np.sum(X_test[i] * bad_vec_trained) + np.log(1-good_pro)

    #若好评概率大于差评概率
    if good_pro_pre > bad_pro_pre:
        result = '0'                     #输出好评

    else:
        result = '1'                     #否则输出差评

    if(y_test[i] == result):            #若预测答案与真实答案相等，预测正确数量增加
        success_count +=1

        
print('朴素贝叶斯模型(bayes)预测的准确度: {}'.format(success_count/2500))


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

朴素贝叶斯模型(bayes)预测的准确度: 0.9392
1

经过对 2500 条测试数据逐一预测，得到该模型的准确度为 93.92%，效果不算太差，模型构建成功，后续可作适当优化。

Step8: 测试评论，输出情绪分类

输入 50 条评论信息，测试模型预测效果

import random

dic_len = len(dictionary)

start = random.randint(50, 2450)

#从测试集中随机抽取50条数据，准备测试
X_data = X_test[start:start+50]
y_data = y_test[start:start+50]

success_test = 0

#对 50条评论信息进行预测
for sequence_index in range(len(X_data)):
    
    #找到该 评论语句 切分后的词组对应的位置，返回一个数组
    locs = np.where(X_data[sequence_index] == 1)
    
    #输出切分、分词后的评论内容
    for loc in locs[0]:
        print(dictionary[loc] ,end='/')
    
    print('\n')
    
    #代入朴素贝叶斯公式
    good_pro_pre = np.sum(X_data[sequence_index] * good_vec_trained) + np.log(good_pro)         #评论好评的概率
    bad_pro_pre = np.sum(X_data[sequence_index] * bad_vec_trained) + np.log(1-good_pro)         #评论差评的概率

    #0 代表好评， 1代表差评
    #若好评概率大于差评概率
    if good_pro_pre > bad_pro_pre:
        result = '0'                     #输出好评
        print('Predict result : 好评', end='\t')
    else:
        result = '1'                     #否则输出差评
        print('Predict result : 差评', end='\t')
    
    #实际该评论的结果
    if y_data[sequence_index] == '0':
        print('Actual results: 好评', end='\t')
    else:   
        print('Actual results: 差评', end='\t')
        
    #判断是否预测正确
    if result == y_data[sequence_index]:
        print('Predict success!', end='\t')
        success_test += 1
    else:
        print('Predict fail!', end='\t')


    print('\n\n')

print('本次测试预测准确度为: {}'.format(success_test/50))
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54