5-RNN-0501_英文情感分析
import numpy as np
import tensorflow as tf
from string import punctuation
from collections import Counter
# 介绍预览该项目，并介绍该项目网络结构！
with open('../datas/sentiment/reviews.txt', 'r') as f:
reviews = f.read()
with open('../datas/sentiment/labels.txt', 'r') as f:
labels = f.read()
print(reviews[0])
# 数据预处理
# todo-1、移除所有标点符号(生成1个没有标点符号的列表，然后再组合成文本)
all_text = ''.join([c for c in reviews if c not in punctuation])
# todo 2、以'\n'为分隔符，拆分所有评论
reviews = all_text.split('\n')
all_text = ' '.join(reviews)
# 文本拆分为单独的单词列表
words = all_text.split()
# todo 1、创建数据字典：{单词：整数}。后面我们会对input向量填充0，编码的整数从1开始（不是0）
# 2、将所有文本转换成为整数，并存储到新的列表中：reviews_ints.
counts = Counter(words)
# 按计数进行排序
vocab = sorted(counts, key=counts.get, reverse=True)
# 生成字典：{单词：整数}
vocab_to_int = {word: ii for ii, word in enumerate(vocab, 1)}
# 将文本列表 转换为 整数列表
reviews_ints = []
for each in reviews:
reviews_ints.append([vocab_to_int[word] for word in each.split()])
# todo-对labels进行编码： 将标签转换为数值：positive==1 和 negative ==0
labels = labels.split('\n')
labels = np.array([1 if each == 'positive' else 0 for each in labels])
# todo-有一个问题：
"""
有一条评论长度为0；且最长的评论长度为2514，过长了一点。所以将其截断成200的长度：
1、评论长度小于200的，对其左边填充0，
2、对于大于200的，只截取其前200个单词。
"""
review_lens = Counter([len(x) for x in reviews_ints])
print("长度为0的评论数量: {}".format(review_lens[0]))
print("最大评论的长度为: {}".format(max(review_lens)))
# todo-从 reviews_ints列表中移除0长度的评论。
# 获得长度非0的 评论的索引号
non_zero_idx = [ii for ii, review in enumerate(reviews_ints) if len(review) != 0]
# 为了确保代码不出错，用in判断下
reviews_ints = [reviews_ints[ii] for ii in non_zero_idx]
labels = np.array([labels[ii] for ii in non_zero_idx])
# todo-练习
"""
需求：用 review_ints中的数据创建数组： features 。要求：每一行都是长度为200：如果评论小于200，那么对其左填充0。
举例：如果评论为 ['best', 'movie', 'ever'], 其整数形式为：[117, 18, 128],那么左填充0后，
应该像这样： [0, 0, 0, ..., 0, 117, 18, 128]；评论大于200字的，只取其前200单词即可。
"""
seq_len = 200
# 生成一个25000*200的全0矩阵。
features = np.zeros((len(reviews_ints), seq_len), dtype=int)
# 将reviews_ints值逐行 赋值给features. 可以print出来检查一下。
for i, row in enumerate(reviews_ints):
features[i, -len(row):] = np.array(row)[:seq_len] # 注意这里的技巧。
# todo-练习 构建训练、验证、测试集。定义了一个拆分的分数 ： split_frac（0。8--0.9） ，按该分数比率保留数据到训练数据集
split_frac = 0.8
split_idx = int(len(features)*0.8)
train_x, val_x = features[:split_idx], features[split_idx:]
train_y, val_y = labels[:split_idx], labels[split_idx:]
test_idx = int(len(val_x)*0.5)
val_x, test_x = val_x[:test_idx], val_x[test_idx:]
val_y, test_y = val_y[:test_idx], val_y[test_idx:]
print("\t\t\tFeature Shapes:")
print("Train set: \t\t{}".format(train_x.shape),
"\nValidation set: \t{}".format(val_x.shape),
"\nTest set: \t\t{}".format(test_x.shape))
# todo-开始创建模型图
lstm_size = 256
lstm_layers = 1
batch_size = 128
learning_rate = 0.001
n_words = len(vocab_to_int)
# todo-练习 创建占位符
# 创建图对象
graph = tf.Graph()
# 将节点添加到图中：
with graph.as_default():
inputs_ = tf.placeholder(tf.int32, [None, None], name='inputs')
labels_ = tf.placeholder(tf.int32, [None, None], name='labels')
keep_prob = tf.placeholder(tf.float32, name='keep_prob')
# todo-练习 创建嵌入层
"""
因为原始单词总量有72000个，直接one-hot编码后输入网络太不效率了，所以我们通过word2vec方法训练一个嵌入权重矩阵。
通过 `tf.Variable`创建embedding查找矩阵 。通过查找嵌入矩阵获得嵌入向量，再传入LSTM cell。 [`tf.nn.embedding_lookup`]
该函数接收 embedding 矩阵，和 input tensor（评论的向量）；返回：嵌入向量 。例如：嵌入层节点数量== 200 ,那么该函数将返回：
一个张量，size== [batch_size, 200].
"""
# 嵌入向量大小embedding vectors(既嵌入层节点数量)
embed_size = 300
with graph.as_default():
embedding = tf.Variable(tf.random_uniform((n_words, embed_size), -1, 1))
embed = tf.nn.embedding_lookup(embedding, inputs_)
with graph.as_default():
# 创建基础的LSTM cell
lstm = tf.nn.rnn_cell.BasicLSTMCell(lstm_size)
# 对cell添加dropout
drop = tf.nn.rnn_cell.DropoutWrapper(lstm, output_keep_prob=keep_prob)
# 堆栈多个LSTM layers
cell = tf.nn.rnn_cell.MultiRNNCell([drop] * lstm_layers)
# 将所有cell初始化为0状态。
initial_state = cell.zero_state(batch_size, tf.float32)
print('initial state的shape是:{}'.format(initial_state))
# todo-RNN正向传播
"""
真正的运行 RNN 节点。需要使用函数 [`tf.nn.dynamic_rnn`]。需要传入2个参数：多层LSTM单元(multiple layered LSTM `cell`),以及输入（inputs）。
outputs, final_state = tf.nn.dynamic_rnn(cell, inputs, initial_state=initial_state)
同时我们将上面定义的 `initial_state`传给了 RNN网络。这是在隐藏层之间传递的单元状态。 `tf.nn.dynamic_rnn` 函数帮我们完成了绝大多数工作。
并返回每一步的输出和隐藏层最终状态。
> **练习:** 使用 `tf.nn.dynamic_rnn`向RNN网络添加正向传播。注意：这里我们传入的inputs，实际是嵌入层（embedding layer）的输出： `embed`。
"""
with graph.as_default():
outputs, final_state = tf.nn.dynamic_rnn(cell, embed,
initial_state=initial_state)
print('final_state的shape 是:{}'.format(final_state))
print('隐藏层的output的shape 是:{}'.format(outputs)) # shape=(batch_size=128, ?, lstm_size=256)
# RNN输出
"""
我们需要抓取最后一个输出，通过：`outputs[:, -1, :]`, 在计算它与`labels_`的损失。
"""
loss_method = 'MSE'
with graph.as_default():
if loss_method == 'MSE':
# 方法1、用最小均方差来做。
predictions = tf.contrib.layers.fully_connected(outputs[:, -1, :], 1, activation_fn=tf.sigmoid)
print('outputs[:, -1]的shape 是:{}'.format(outputs[:, -1, :])) # shape=(batch=128, lstm_size=256)
cost = tf.losses.mean_squared_error(labels_, predictions)
else:
# 方法2：用sigmoid交叉熵来做。
logits = tf.contrib.layers.fully_connected(outputs[:, -1, :], 1, activation_fn=None)
predictions = tf.nn.sigmoid(logits)
cost = tf.reduce_mean(tf.nn.sigmoid_cross_entropy_with_logits(
labels=tf.cast(labels_, tf.float32), logits=logits))
optimizer = tf.train.AdamOptimizer(learning_rate).minimize(cost)
# Validation accuracy
with graph.as_default():
correct_pred = tf.equal(tf.cast(tf.round(predictions), tf.int32), labels_)
accuracy = tf.reduce_mean(tf.cast(correct_pred, tf.float32))
# todo 定义batch函数。1、我们移除了最后一个batch，以便我们的batches是齐整的。
# 2、迭代 `x` 和 `y` 数组，以 `[batch_size]`为单位，返回上述数组的切片。
def get_batches(x, y, batch_size=128):
n_batches = len(x) // batch_size
x, y = x[:n_batches * batch_size], y[:n_batches * batch_size]
for ii in range(0, len(x), batch_size):
yield x[ii:ii + batch_size], y[ii:ii + batch_size]
# 训练
def training():
epochs = 20
with graph.as_default():
saver = tf.train.Saver()
with tf.Session(graph=graph) as sess:
sess.run(tf.global_variables_initializer())
iteration = 1
for e in range(epochs):
# 要先跑 state
state = sess.run(initial_state)
for ii, (x, y) in enumerate(get_batches(train_x, train_y, batch_size), 1):
feed = {inputs_: x,
labels_: y[:, None],
keep_prob: 0.5,
initial_state: state}
# todo - 跑出来的state 下一个batch又喂给了模型。
loss, state, _ = sess.run([cost, final_state, optimizer], feed_dict=feed)
if iteration % 5 == 0:
print("Epoch: {}/{}".format(e, epochs),
"Iteration: {}".format(iteration),
"Train loss: {:.3f}".format(loss))
if iteration % 25 == 0:
# 跑验证数据
val_acc = []
val_state = sess.run(cell.zero_state(batch_size, tf.float32))
for x, y in get_batches(val_x, val_y, batch_size):
feed = {inputs_: x,
labels_: y[:, None],
keep_prob: 1,
initial_state: val_state}
batch_acc, val_state = sess.run([accuracy, final_state], feed_dict=feed)
val_acc.append(batch_acc)
print("Val acc: {:.5f}".format(np.mean(val_acc)))
iteration += 1
saver.save(sess, "checkpoints/sentiment.ckpt")
# 测试：
def testing():
test_acc = []
with graph.as_default():
saver = tf.train.Saver()
with tf.Session(graph=graph) as sess:
saver.restore(sess, tf.train.latest_checkpoint('checkpoints'))
test_state = sess.run(cell.zero_state(batch_size, tf.float32))
for ii, (x, y) in enumerate(get_batches(test_x, test_y, batch_size), 1):
feed = {inputs_: x,
labels_: y[:, None],
keep_prob: 1,
initial_state: test_state}
batch_acc, test_state = sess.run([accuracy, final_state], feed_dict=feed)
test_acc.append(batch_acc)
print("Test accuracy: {:.5f}".format(np.mean(test_acc)))
if __name__ == '__main__':
training()
作者：HJZ11
