【人工智能项目】LSTM实现电影评论情感分类实验_基于lstm的影评分类情感分析识别系统设计与实现

【人工智能项目】LSTM实现电影评论情感分类实验

本次对电影评论的情感进行分析，看是否为积极评论还是消极评论。

本次所用数据集

import os

data_dir = "./Dataset"
print(os.listdir(data_dir))
1
2
3
4

['test.txt', 'train.txt', 'validation.txt', 'wiki_word2vec_50.bin']
1

导包

import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns
import os
import time
import datetime

from sklearn.model_selection import train_test_split
from sklearn.preprocessing import LabelEncoder
from sklearn.utils import class_weight as cw

from keras import Sequential

from keras.models import Model

from keras.layers import LSTM,Activation,Dense,Dropout,Input,Embedding,BatchNormalization,Add,concatenate,Flatten
from keras.layers import Conv1D,Conv2D,Convolution1D,MaxPool1D,SeparableConv1D,SpatialDropout1D,GlobalAvgPool1D,GlobalMaxPool1D,GlobalMaxPooling1D
from keras.layers.pooling import _GlobalPooling1D
from keras.layers import MaxPooling2D,GlobalMaxPooling2D,GlobalAveragePooling2D

from keras.optimizers import RMSprop,Adam

from keras.preprocessing.text import Tokenizer
from keras.preprocessing import sequence

from keras.utils import to_categorical

from keras.callbacks import EarlyStopping
from keras.callbacks import ModelCheckpoint
from keras.callbacks import ReduceLROnPlateau

%matplotlib inline

import warnings
warnings.filterwarnings("ignore")
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

Using TensorFlow backend.
1

导入数据

train_df = pd.read_csv("./Dataset/train.txt",encoding="utf-8",header=None,sep="\t",names=["label","text"])
valid_df = pd.read_csv("./Dataset/validation.txt",encoding="utf-8",header=None,sep="\t",names=["label","text"])
test_df = pd.read_csv("./Dataset/test.txt",encoding="utf-8",header=None,sep="\t",names=["label","text"])
1
2
3

train_df
1

19998 rows × 2 columns

# 重新排序
train_df = train_df.sample(frac=1).reset_index(drop=True)
1
2

train_df
1

19998 rows × 2 columns

valid_df
1

5629 rows × 2 columns

# 重新排序
valid_df = valid_df.sample(frac=1).reset_index(drop=True)
1
2

valid_df
1

5629 rows × 2 columns

test_df
1

369 rows × 2 columns

# 重新排序
test_df = test_df.sample(frac=1).reset_index(drop=True)
1
2

test_df
1

369 rows × 2 columns

print(train_df.shape,valid_df.shape,test_df.shape)
1

(19998, 2) (5629, 2) (369, 2)
1

valid_df = pd.concat([valid_df,test_df[:50]],axis=0)
1

# 合并
train_df = pd.concat([train_df,valid_df],axis=0)
print(train_df.shape)
1
2
3

(25677, 2)
1

# 统计一下
sns.countplot(train_df["label"])
plt.title("Number of ham and spam messages")
plt.xlabel("Label")
1
2
3
4

Text(0.5, 0, 'Label')
1

标签数据处理

# 对标签进行处理
#  LabelEncoder 是对不连续的数字或者文本进行编号
# LabelEncoder可以将标签分配一个0—n_classes-1之间的编码

x_train = train_df["text"]
y_train = train_df["label"]


le = LabelEncoder()
y_train = le.fit_transform(y_train)
y_train = y_train.reshape(-1,1)
1
2
3
4
5
6
7
8
9
10
11

文本数据处理

# 分词器Tokenizer   Tokenizer是一个用于向量化文本，或将文本转换为序列（即单词在字典中的下标构成的列表，从1算起）的类
       # 类方法
           # fit_on_texts(texts) :texts用于训练的文本列表
          # texts_to_sequences(texts):texts待转为序列的文本列表 返回值:序列的列表，列表中的每个序列对应于一段输入文本

# 填充序列pad_sequences  将长为nb_smaples的序列转换为(nb_samples,nb_timesteps)2Dnumpy attay.如果提供maxlen,nb_timesteps=maxlen,
#否则其值为最长序列的长度。
# 其它短于该长度的序列都会在后部填充0以达到该长度。长与nb_timesteps的序列会被阶段，以使其匹配该目标长度。

#max_words = 1000
#max_len = 150
max_words = len(set(" ".join(x_train).split()))
max_len = x_train.apply(lambda x:len(x)).max()


tok = Tokenizer(num_words=max_words)

tok.fit_on_texts(x_train)

sequences = tok.texts_to_sequences(x_train)
sequences_matrix = sequence.pad_sequences(sequences,maxlen=max_len)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

• ModelCheckpoint：

  • 作用：该回调函数将在每个epoch后保存模型到filepath
  • 参数：
    • filename:字符串，保存模型的路径，filepath可以是格式化的字符串，里面的
    • monitor:需要监视的值，通常为:val_acc或val_loss或acc或loss
    • verbose:信息展示模型，0或1。默认为0表示不输出该信息，为1表示输出epoch模型保存信息。
    • save_best_only:当设置为Trur时，将只保存在验证集上性能最好的模型
    • mode:“auto”,“min”,"max"之一，在save_best_only=True时决定性能最佳模型的评判准则。
    • save_weights_only:若设置为True时，则只保存模型权重，否则将保存整个模型（包括模型结构，配置信息等）
    • period:CheckPoint之间的间隔的epoch数

• EarlyStopping：

  • 作用：当监测值不再改善时，该回调函数将中止训练
  • 参数：
    • monitor:需要监视的量，通常为val_acc或val_loss或acc或loss
    • patience:当early stop被激活（如发现loss相比上patience个epoch训练没有下降），则经过patience个epoch后停止训练。
    • verbose:信息展示模型
    • mode:“auto”,“min”,"max"之一，在min模式下，如果检测值停止下降则中止训练。在max模式下，当检测值不再上升则停止训练。

• ReduceLROnPlateau:

  • 作用：当评价指标不再提升时，减少学习率。当学习停滞时，减少2倍或10倍的学习率通常能够获得较好的效果。该回调函数检测指标的情况，如果在patience个epoch中看不到模型性能提升，则减少学习率。
  • 参数：
    • monitor:被监测的量
    • factor:每次减少学习率的因子，学习率将以lr=lr*factor的形式被技术那好
    • patience：当patience个epoch过去而模型性能不提升时，学习率减少的动作会被触发
    • mode:“auto”,“min”,"max"之一，在min模式下，如果检测值触发学习率减少。在max模式下，当检测值不再上升则触发学习率减少
    • epsilon:阈值，用来确定是否进入检测值的“平原区”
    • cooldown:学习率减少后，会经过cooldown个epoch才重新进行正常操作
    • min_lr:学习率的下限。

print("Setting Callbacks")

checkpoint = ModelCheckpoint("model.h5",
                                                     monitor="val_acc",
                                                     verbose=1,
                                                     save_best_only=True,
                                                     mode="max")

early_stopping = EarlyStopping(monitor="val_loss",
                                                     patience=3,
                                                     verbose=1,
                                                     restore_best_weights=True,
                                                     mode="min")

reduce_lr = ReduceLROnPlateau(monitor="val_loss",
                                                      factor=0.5,
                                                      patience=2,
                                                      verbose=1,
                                                      mode="min")

callbacks=[checkpoint,early_stopping,reduce_lr]
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

Setting Callbacks
1

定义深度学习模型

# 定义RNN模型
def RNN():
    model = Sequential()
    
    model.add(Embedding(max_words,128,input_length=max_len))
    model.add(LSTM(64))
    
    model.add(Dropout(0.5))
    model.add(BatchNormalization())
    
    model.add(Dense(256,activation="relu"))
    model.add(Dropout(0.5))
    model.add(BatchNormalization())
    
    model.add(Dense(64,activation="relu"))

    model.add(Dropout(0.5))
    
    model.add(Dense(1,activation="sigmoid"))
    
    model.summary()
    
    return model
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

# 画曲线
def plot_performance(history=None,figure_directory=None,ylim_pad=[0,0]):
    xlabel="Epoch"
    legends=["Training","Validation"]
    
    plt.figure(figsize=(20,5))
    
    y1=history.history["accuracy"]
    y2=history.history["val_accuracy"]
    
    min_y=min(min(y1),min(y2))-ylim_pad[0]
    max_y=max(max(y1),max(y2))+ylim_pad[0]
    
    plt.subplot(121)
    
    plt.plot(y1)
    plt.plot(y2)
    
    plt.title("Model Accuracy\n",fontsize=17)
    plt.xlabel(xlabel,fontsize=15)
    plt.ylabel("Accuracy",fontsize=15)
    plt.ylim(min_y,max_y)
    plt.legend(legends,loc="upper left")
    plt.grid()
    
    y1=history.history["loss"]
    y2=history.history["val_loss"]
    
    min_y=min(min(y1),min(y2))-ylim_pad[1]
    max_y=max(max(y1),max(y2))+ylim_pad[1]
    
    plt.subplot(122)
    
    plt.plot(y1)
    plt.plot(y2)
    
    plt.title("Model Loss:\n",fontsize=17)
    plt.xlabel(xlabel,fontsize=15)
    plt.ylabel("Loss",fontsize=15)
    plt.ylim(min_y,max_y)
    plt.legend(legends,loc="upper left")
    plt.grid()
    plt.show()
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

RNN

rnn_model = RNN()
1

Model: "sequential_1"
_________________________________________________________________
Layer (type)                 Output Shape              Param #   
=================================================================
embedding_1 (Embedding)      (None, 1954, 128)         7551616   
_________________________________________________________________
lstm_1 (LSTM)                (None, 64)                49408     
_________________________________________________________________
dropout_1 (Dropout)          (None, 64)                0         
_________________________________________________________________
batch_normalization_1 (Batch (None, 64)                256       
_________________________________________________________________
dense_1 (Dense)              (None, 256)               16640     
_________________________________________________________________
dropout_2 (Dropout)          (None, 256)               0         
_________________________________________________________________
batch_normalization_2 (Batch (None, 256)               1024      
_________________________________________________________________
dense_2 (Dense)              (None, 64)                16448     
_________________________________________________________________
dropout_3 (Dropout)          (None, 64)                0         
_________________________________________________________________
dense_3 (Dense)              (None, 1)                 65        
=================================================================
Total params: 7,635,457
Trainable params: 7,634,817
Non-trainable params: 640
_________________________________________________________________
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

loss = "binary_crossentropy"
metrics=["accuracy"]
1
2

# RNN模型训练
print("Starting...\n")
learning_rate=0.001
optimizer=Adam(learning_rate)

print("\n\nCompliling Model...\n")
rnn_model.compile(optimizer=optimizer,
                                 loss=loss,
                                 metrics=metrics)

verbose = 1
epochs=100
batch_size=128
validation_split=0.1
print("Trainning Model...\n")

rnn_history=rnn_model.fit(sequences_matrix,
                                            y_train,
                                            batch_size=batch_size,
                                            epochs=epochs,
                                            verbose=1,
                                            callbacks=callbacks,
                                            validation_split=validation_split)

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

Starting...



Compliling Model...

WARNING:tensorflow:From D:\software\Anaconda\anaconda\envs\tensorflow\lib\site-packages\tensorflow\python\ops\nn_impl.py:180: add_dispatch_support.<locals>.wrapper (from tensorflow.python.ops.array_ops) is deprecated and will be removed in a future version.
Instructions for updating:
Use tf.where in 2.0, which has the same broadcast rule as np.where
Trainning Model...

WARNING:tensorflow:From D:\software\Anaconda\anaconda\envs\tensorflow\lib\site-packages\keras\backend\tensorflow_backend.py:422: The name tf.global_variables is deprecated. Please use tf.compat.v1.global_variables instead.

Train on 23109 samples, validate on 2568 samples
Epoch 1/100
23109/23109 [==============================] - 320s 14ms/step - loss: 0.6358 - accuracy: 0.6747 - val_loss: 0.6019 - val_accuracy: 0.8236
Epoch 2/100
23109/23109 [==============================] - 317s 14ms/step - loss: 0.2775 - accuracy: 0.8940 - val_loss: 0.4068 - val_accuracy: 0.8162
Epoch 3/100
23109/23109 [==============================] - 319s 14ms/step - loss: 0.1187 - accuracy: 0.9601 - val_loss: 0.4475 - val_accuracy: 0.8185
Epoch 4/100
23109/23109 [==============================] - 325s 14ms/step - loss: 0.0608 - accuracy: 0.9803 - val_loss: 0.9544 - val_accuracy: 0.7819

Epoch 00004: ReduceLROnPlateau reducing learning rate to 0.0005000000237487257.
Epoch 5/100
23109/23109 [==============================] - 325s 14ms/step - loss: 0.0285 - accuracy: 0.9904 - val_loss: 0.7304 - val_accuracy: 0.8209
Restoring model weights from the end of the best epoch
Epoch 00005: early stopping
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

# 可视化
plot_performance(history=rnn_history)
1
2

验证结果

# 数据导入
data = pd.read_csv("./Dataset/test.txt",encoding="utf-8",header=None,sep="\t",names=["label","text"])
data.head()
1
2
3

y_test = data["label"]
y_test = np.array(y_test)
1
2

predict_data = data["text"]
1

# 将带预测数据转为序列
predict_sequences = tok.texts_to_sequences(predict_data)
predict_sequences_matrix = sequence.pad_sequences(predict_sequences,maxlen=max_len)

1
2
3
4

# RNN预测
rnn_predict_num = rnn_model.predict_classes(predict_sequences_matrix )
1
2

predict = rnn_predict_num[:,0]
1

predict
1

array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
       1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1, 0, 1, 1, 0, 1, 1, 1,
       1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1,
       1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1,
       1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 1,
       1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0,
       1, 1, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
       1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1,
       1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0,
       0, 0, 1, 0, 1, 0, 1, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0,
       0, 1, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0,
       0, 0, 0, 1, 0, 0, 1, 1, 0, 0, 0, 0, 1, 1, 0, 0, 1, 0, 0, 0, 0, 0,
       1, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1,
       0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0,
       0, 0, 0, 0, 1, 0, 0, 1, 1, 0, 0, 1, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0,
       0, 0, 0, 1, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 1, 0, 0, 1, 0, 0,
       0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 1])
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

y_test
1

array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
       1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
       1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
       1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
       1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
       1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
       1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
       1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
       1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], dtype=int64)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

from sklearn.metrics import accuracy_score

print(accuracy_score(predict,y_test))
1
2
3

0.8373983739837398
1

小结

点赞收藏评论走起来，亲爱的瓷们！！！！