超级会员免费看
利用循环神经网络对序列数据进行建模
1. 长短期记忆单元（LSTM）
LSTM最初是为了解决梯度消失问题而提出的。其基本构建块是记忆单元，它本质上代表或替代了标准RNN的隐藏层。
在每个记忆单元中，存在一个权重 $w = 1$ 的循环边，这有助于克服梯度消失和梯度爆炸问题。与该循环边相关的值被统称为单元状态。现代LSTM单元的展开结构如下：
当前时间步的单元状态 $C(t)$ 是由上一个时间步的单元状态 $C(t - 1)$ 经过修改得到的，且不直接与任何权重因子相乘。记忆单元中的信息流动由几个计算单元（通常称为门）控制。其中，$\odot$ 表示逐元素相乘，$\bigoplus$ 表示逐元素相加，$x(t)$ 指时间 $t$ 的输入数据，$h(t - 1)$ 表示时间 $t - 1$ 的隐藏单元。有四个带有激活函数（sigmoid函数 $\sigma$ 或tanh）和一组权重的方框，它们通过对输入（$h(t - 1)$ 和 $x(t)$）进行矩阵 - 向量乘法来执行线性组合，这些具有sigmoid激活函数且输出单元经过 $\odot$ 运算的计算单元被称为门。
LSTM单元中有三种不同类型的门：
-
遗忘门（$f_t$）
：允许记忆单元重置单元状态，避免其无限增长。它决定哪些信息可以通过，哪些信息需要抑制。计算公式为：$f_t = \sigma(W_{xf}x(t) + W_{hf}h(t - 1) + b_f)$。遗忘门并非原始LSTM单元的一部分，是后来为改进原始模型而添加的。
-
输入门（$i_t$）和候选值（$\tilde{C}_t$）
：负责更新单元状态。计算公式分别为：$i_t = \sigma(W_{xi}x(t) + W_{hi}h(t - 1) + b_i)$，$\tilde{C}
t = \tanh(W
{xc}x(t) + W_{hc}h(t - 1) + b_c)$。时间 $t$ 的单元状态计算公式为：$C(t) = (C(t - 1) \odot f_t) \bigoplus (i_t \odot \tilde{C}
t)$。
-
输出门（$o_t$）
：决定如何更新隐藏单元的值。计算公式为：$o_t = \sigma(W
{xo}x(t) + W_{ho}h(t - 1) + b_o)$。当前时间步的隐藏单元计算公式为：$h(t) = o_t \odot \tanh(C(t))$。
虽然LSTM单元的结构和计算看似复杂，但TensorFlow已经在优化的包装函数中实现了一切，方便我们轻松高效地定义LSTM单元。
2. 在TensorFlow中实现用于序列建模的RNN
在了解了RNN的基本理论后，接下来将进入更实际的部分：在TensorFlow中实现RNN。后续会将RNN应用于两个常见的问题任务：
1. 情感分析
2. 语言建模
2.1 其他先进的RNN模型
LSTM为建模序列中的长距离依赖提供了基本方法，但文献中还有许多LSTM的变体。此外，2014年提出的门控循环单元（GRU）也是一种较新的方法。GRU的架构比LSTM更简单，计算效率更高，在某些任务（如复调音乐建模）中的性能与LSTM相当。
2.2 项目一：预测IMDb电影评论的情感
情感分析旨在分析句子或文本文档所表达的观点。这里将实现一个多层RNN用于情感分析，采用多对一的架构。
2.2.1 准备电影评论数据
之前预处理得到了名为
movie_data.csv
的干净数据集，现在将使用它。首先导入必要的模块并将数据读入pandas DataFrame：
import tensorflow as tf
import tensorflow_datasets as tfds
import numpy as np
import pandas as pd
df = pd.read_csv('movie_data.csv', encoding='utf-8')
该DataFrame包含两列：
review
（电影评论的文本，即输入特征）和
sentiment
（要预测的目标标签，0表示负面情感，1表示正面情感）。RNN模型将把每个评论序列分类为正面（1）或负面（0）评论。
在将数据输入RNN模型之前，需要进行以下预处理步骤：
1. 创建一个TensorFlow数据集对象，并将其拆分为单独的训练、测试和验证分区。
2. 识别训练数据集中的唯一单词。
3. 将每个唯一单词映射到一个唯一整数，并将评论文本编码为编码整数（每个唯一单词的索引）。
4. 将数据集划分为小批量作为模型的输入。
步骤1：创建数据集
target = df.pop('sentiment')
ds_raw = tf.data.Dataset.from_tensor_slices((df.values, target.values))
# 检查数据
for ex in ds_raw.take(3):
tf.print(ex[0].numpy()[0][:50], ex[1])
将数据集拆分为训练、测试和验证数据集：
tf.random.set_seed(1)
ds_raw = ds_raw.shuffle(50000, reshuffle_each_iteration=False)
ds_raw_test = ds_raw.take(25000)
ds_raw_train_valid = ds_raw.skip(25000)
ds_raw_train = ds_raw_train_valid.take(20000)
ds_raw_valid = ds_raw_train_valid.skip(20000)
步骤2：查找唯一标记（单词）
from collections import Counter
tokenizer = tfds.features.text.Tokenizer()
token_counts = Counter()
for example in ds_raw_train:
tokens = tokenizer.tokenize(example[0].numpy()[0])
token_counts.update(tokens)
print('Vocab-size:', len(token_counts))
步骤3：将唯一标记编码为整数
encoder = tfds.features.text.TokenTextEncoder(token_counts)
example_str = 'This is an example!'
print(encoder.encode(example_str))
对于验证或测试数据中可能存在的未在训练数据中出现的标记，将其分配整数
q + 1
（这里
q
是传递给
TokenTextEncoder
的
token_counts
的大小），整数0用作调整序列长度的占位符。
为了处理数据集中文本数据被封装在张量对象中的问题，定义两个函数：
# 步骤3 - A：定义转换函数
def encode(text_tensor, label):
text = text_tensor.numpy()[0]
encoded_text = encoder.encode(text)
return encoded_text, label
# 步骤3 - B：将编码函数包装为TensorFlow操作
def encode_map_fn(text, label):
return tf.py_function(encode, inp=[text, label], Tout=(tf.int64, tf.int64))
ds_train = ds_raw_train.map(encode_map_fn)
ds_valid = ds_raw_valid.map(encode_map_fn)
ds_test = ds_raw_test.map(encode_map_fn)
# 查看一些示例的形状
tf.random.set_seed(1)
for example in ds_train.shuffle(1000).take(5):
print('Sequence length:', example[0].shape)
目前已将单词序列转换为整数序列，但序列长度不同。虽然RNN通常可以处理不同长度的序列，但为了将它们有效地存储在张量中，需要确保小批量中的所有序列具有相同的长度。TensorFlow提供了
padded_batch()
方法来实现这一点：
# 取一个小的子集
ds_subset = ds_train.take(8)
for example in ds_subset:
print('Individual size:', example[0].shape)
# 将数据集划分为批次
ds_batched = ds_subset.padded_batch(4, padded_shapes=([-1], []))
for batch in ds_batched:
print('Batch dimension:', batch[0].shape)
# 将所有三个数据集划分为小批量，批量大小为32
train_data = ds_train.padded_batch(32, padded_shapes=([-1],[]))
valid_data = ds_valid.padded_batch(32, padded_shapes=([-1],[]))
test_data = ds_test.padded_batch(32, padded_shapes=([-1],[]))
2.3 用于句子编码的嵌入层
之前的数据准备生成了相同长度的序列，其元素是对应唯一单词索引的整数。将这些单词索引转换为输入特征有多种方法。一种简单的方法是使用独热编码，但这可能导致模型遭受维度灾难，且特征非常稀疏。
更优雅的方法是将每个单词映射到一个固定大小的实值向量，这就是嵌入的思想。嵌入是一种特征学习技术，可以自动学习表示数据集中单词的显著特征。与独热编码相比，嵌入具有以下优点：
- 减少特征空间的维度，降低维度灾难的影响。
- 提取显著特征，因为神经网络中的嵌入层可以被优化（或学习）。
在实践中，可以使用
tf.keras.layers.Embedding
创建嵌入层。例如：
from tensorflow.keras.layers import Embedding
model = tf.keras.Sequential()
model.add(Embedding(input_dim=100, output_dim=6, input_length=20, name='embed-layer'))
model.summary()
该模型（嵌入层）的输入必须是二维的，维度为
batch_size × input_length
，输出维度为
batch_size × input_length × embedding_dim
。
2.4 构建RNN模型
使用Keras的
Sequential
类，可以将嵌入层、RNN的循环层和全连接的非循环层组合起来。循环层可以使用以下实现之一：
-
SimpleRNN
：常规的RNN层，即全连接的循环层。
-
LSTM
：长短期记忆RNN，用于捕捉长期依赖。
-
GRU
：带有门控循环单元的循环层，是LSTM的替代方案。
以下是一个使用
SimpleRNN
构建多层RNN模型的示例：
from tensorflow.keras import Sequential
from tensorflow.keras.layers import Embedding
from tensorflow.keras.layers import SimpleRNN
from tensorflow.keras.layers import Dense
model = Sequential()
model.add(Embedding(input_dim=1000, output_dim=32))
model.add(SimpleRNN(32, return_sequences=True))
model.add(SimpleRNN(32))
model.add(Dense(1))
model.summary()
通过以上步骤，我们完成了从理论到实践的过程，实现了在TensorFlow中使用RNN对序列数据进行建模，包括LSTM单元的介绍、数据预处理、嵌入层的使用以及RNN模型的构建。这些步骤为解决情感分析和语言建模等实际问题奠定了基础。
下面通过一个流程图来总结整个数据预处理和模型构建的流程：
graph TD;
A[读取数据] --> B[创建TensorFlow数据集];
B --> C[拆分数据集];
C --> D[查找唯一标记];
D --> E[编码唯一标记为整数];
E --> F[处理序列长度];
F --> G[嵌入层处理];
G --> H[构建RNN模型];
整个过程的步骤总结如下表：
|步骤|操作|
|----|----|
|1|读取电影评论数据|
|2|创建TensorFlow数据集并拆分|
|3|查找训练数据集中的唯一单词|
|4|将唯一单词编码为整数|
|5|处理序列长度差异|
|6|使用嵌入层减少维度|
|7|构建RNN模型|
通过以上的介绍和操作步骤，我们可以在TensorFlow中有效地实现用于序列建模的RNN，为解决实际问题提供了有力的工具。
3. 训练和评估RNN模型
3.1 编译模型
在构建好RNN模型后，需要对其进行编译，指定损失函数、优化器和评估指标。对于情感分析任务，通常使用二元交叉熵损失函数，因为目标标签是二元的（0或1）。优化器可以选择Adam，它是一种常用且有效的优化算法。评估指标选择准确率，以直观地了解模型的性能。
model.compile(loss='binary_crossentropy', optimizer='adam', metrics=['accuracy'])
3.2 训练模型
使用之前准备好的训练数据和验证数据对模型进行训练。可以指定训练的轮数（epochs）和批量大小（batch size）。
history = model.fit(train_data, epochs=10, validation_data=valid_data)
3.3 评估模型
使用测试数据对训练好的模型进行评估，得到模型在测试集上的损失和准确率。
test_loss, test_acc = model.evaluate(test_data)
print(f'Test accuracy: {test_acc}')
3.4 可视化训练过程
为了更直观地观察模型的训练过程，可以绘制训练和验证的损失曲线以及准确率曲线。
import matplotlib.pyplot as plt
# 绘制损失曲线
plt.plot(history.history['loss'], label='Training Loss')
plt.plot(history.history['val_loss'], label='Validation Loss')
plt.xlabel('Epochs')
plt.ylabel('Loss')
plt.legend()
plt.show()
# 绘制准确率曲线
plt.plot(history.history['accuracy'], label='Training Accuracy')
plt.plot(history.history['val_accuracy'], label='Validation Accuracy')
plt.xlabel('Epochs')
plt.ylabel('Accuracy')
plt.legend()
plt.show()
3.5 模型调优
如果模型在训练集和验证集上的性能差异较大，可能存在过拟合问题。可以尝试以下方法进行调优：
-
增加数据
：收集更多的训练数据，以提高模型的泛化能力。
-
正则化
：在模型中添加正则化项，如L1或L2正则化，以减少模型的复杂度。
-
早停策略
：在验证损失不再下降时提前停止训练，避免过拟合。
from tensorflow.keras.callbacks import EarlyStopping
early_stopping = EarlyStopping(monitor='val_loss', patience=3)
history = model.fit(train_data, epochs=20, validation_data=valid_data, callbacks=[early_stopping])
4. 语言建模应用
4.1 语言建模简介
语言建模是自然语言处理中的一个重要任务，其目标是预测给定上下文下下一个单词的概率。语言建模有广泛的应用，如机器翻译、文本生成、语音识别等。这里将实现一个多对多的RNN用于语言建模。
4.2 准备语言建模数据
语言建模的数据通常是文本序列，需要将其转换为适合RNN输入的格式。可以将文本分割成固定长度的序列，并将每个单词映射到一个唯一的整数。
# 假设已经有一个文本数据集 text_data
from tensorflow.keras.preprocessing.text import Tokenizer
from tensorflow.keras.preprocessing.sequence import pad_sequences
# 创建分词器
tokenizer = Tokenizer()
tokenizer.fit_on_texts(text_data)
total_words = len(tokenizer.word_index) + 1
# 将文本转换为序列
input_sequences = []
for line in text_data:
token_list = tokenizer.texts_to_sequences([line])[0]
for i in range(1, len(token_list)):
n_gram_sequence = token_list[:i+1]
input_sequences.append(n_gram_sequence)
# 填充序列
max_sequence_length = max([len(x) for x in input_sequences])
input_sequences = pad_sequences(input_sequences, maxlen=max_sequence_length)
# 划分输入和目标
xs = input_sequences[:,:-1]
labels = input_sequences[:,-1]
# 对目标进行独热编码
import numpy as np
ys = np.eye(total_words)[labels]
4.3 构建语言建模RNN模型
使用Keras构建一个用于语言建模的RNN模型，包含嵌入层、LSTM层和全连接输出层。
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Embedding, LSTM, Dense
model = Sequential()
model.add(Embedding(input_dim=total_words, output_dim=100, input_length=max_sequence_length - 1))
model.add(LSTM(150))
model.add(Dense(total_words, activation='softmax'))
model.compile(loss='categorical_crossentropy', optimizer='adam', metrics=['accuracy'])
4.4 训练语言建模模型
使用准备好的数据对语言建模模型进行训练。
history = model.fit(xs, ys, epochs=100, verbose=1)
4.5 文本生成
训练好的语言建模模型可以用于文本生成。给定一个起始文本，模型可以预测下一个单词，不断重复这个过程，生成一段文本。
def generate_text(seed_text, next_words, model, max_sequence_length):
for _ in range(next_words):
token_list = tokenizer.texts_to_sequences([seed_text])[0]
token_list = pad_sequences([token_list], maxlen=max_sequence_length - 1, padding='pre')
predicted = model.predict_classes(token_list, verbose=0)
output_word = ""
for word, index in tokenizer.word_index.items():
if index == predicted:
output_word = word
break
seed_text += " " + output_word
return seed_text
seed_text = "Once upon a time"
generated_text = generate_text(seed_text, 20, model, max_sequence_length)
print(generated_text)
4.6 语言建模流程总结
以下是语言建模的整体流程，通过流程图展示：
graph TD;
A[准备文本数据] --> B[分词并生成序列];
B --> C[填充序列];
C --> D[划分输入和目标];
D --> E[构建RNN模型];
E --> F[训练模型];
F --> G[文本生成];
语言建模的步骤也可以总结为以下表格：
|步骤|操作|
|----|----|
|1|准备文本数据|
|2|使用分词器将文本转换为序列|
|3|填充序列以确保长度一致|
|4|划分输入和目标|
|5|构建包含嵌入层、LSTM层和全连接层的RNN模型|
|6|训练模型|
|7|使用训练好的模型进行文本生成|
5. 总结
本文详细介绍了如何使用循环神经网络（RNN）对序列数据进行建模，包括长短期记忆单元（LSTM）的原理、在TensorFlow中实现RNN的具体步骤、情感分析和语言建模两个实际应用。通过情感分析项目，我们了解了数据预处理的重要性，包括创建数据集、查找唯一标记、编码标记、处理序列长度差异以及使用嵌入层减少维度等操作。在语言建模应用中，我们学习了如何准备数据、构建模型、训练模型以及进行文本生成。
通过合理选择RNN的类型（如SimpleRNN、LSTM、GRU）和合适的模型结构，可以有效地处理序列数据中的长期依赖关系，提高模型的性能。同时，对模型进行编译、训练、评估和调优也是确保模型能够在实际应用中取得良好效果的关键步骤。希望本文能为读者在使用RNN进行序列数据建模方面提供有价值的参考和指导。
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
