《Python深度学习》读书笔记：第6章 深度学习用于文本和序列
目录
第6章 深度学习用于文本和序列
6.1 处理文本数据
6.1.1 单词和字符的one-hot编码
6.1.2 使用词嵌入
6.1.3 整合在一起：从原始文本到词嵌入
6.1.4 小结
6.2 理解循环神经网络
6.2.1 Keras中的循环层
第6章 深度学习用于文本和序列
本章将介绍使用深度学习模型处理文本（可以将其理解为单词序列或字符序列）、时间序列和一般的序列数据。用于处理序列的两种基本的深度学习算法分别是循环神经网络和一维卷积神经网络。这些算法的应用包括：
1.文档分类和时间序列分类，比如识别文章的主题或书的作者；
2.时间序列对比，比如估测两个文档或两支股票行情的相关程度；
3.序列到序列的学习，比如将英语翻译成法语；
4.情感分析，比如将推文或电影评论的情感划分为正面或负面；
5.时间序列预测，比如根据某地最近的天气数据来预测未来天气。
6.1 处理文本数据
文本是最常用的序列数据之一，可以理解为字符序列或单词序列，但最常见的是单词级处理。深度学习用于自然语言处理是将模式识别应用于单词、句子和段落，这与计算机视觉是将模式识别应用于像素大致相同。
与其他所有神经网络一样，深度学习模型不会接收原始文本作为输入，它只能处理数值张量，文本向量化是指将文本转换为数值张量的过程。它由多种实现方法。
1.将文本分割为单词，并将每个单词转换为一个向量；
2.将文本分割为字符，并将每个字符转换为一个向量；
3.提取单词或字符的n-gram，并将每个n-gram转换为一个向量。n-gram是多个连续单词或字符的集合（n-gram之间可重叠）。
将文本分解而成的单元（单词、字符或n-gram）叫做标记，将文本分解成标记的过程叫做分词。所有文本向量化过程都是应用某种分词方案，然后将数值向量与生成的标记相关联。这些向量组合成序列张量，被输入到深度神经网络中。将向量与标记相关联的方法有很多种。
两种主要方法：对标记做one-hot编码与标记嵌入（通常只用于单词，叫作词嵌入）。
理解n-gram和词袋
n-gram是从一个句子中提取的N个（或更少）连续单词的集合。这一概念中的“单词”也可以替换为“字符”。
这样的集合分别叫做二元语法袋及三元语法袋。这里袋这一术语指的是，我们处理的是标记组成的集合，而不是一个列表或序列，即标记没有特定的顺序。这一系列分词方法叫做词袋。
词袋是一种不保存顺序的分词方法（生成的标记组成一个集合，而不是一个序列，舍弃了句子的总体结构），因此它往往被用于浅层的语言处理模型，而不是深度学习模型。提取n-gram是一种特征工程，深度学习不需要这种死板而又不稳定的方法，并将其替换为分层特征学习。在使用轻量级的浅层文本处理模型（比如logistic回归和随机森林），n-gram是一种功能强大、不可或缺的特征工程工具。
6.1.1 单词和字符的one-hot编码
one-hot编码是将标记转换为向量的最常用、最基本的方法。它是将每个单词与唯一的整数索引相关联，然后将这个整数索引i转换为长度为N的二进制向量（N是词表大小），这个向量只有第i个元素是1，其余元素都为0。当然，也可以进行字符级的one-hot编码。
单词级的one-hot编码：
# 初始数据：每个样本是列表的一个元素。利用split方法对样本进行分词，在实际应用中，还需要从样本中去掉标点和特殊字符。
import numpy as np
samples = ['The cat sat on the mat', 'The dog ate my homework']
token_index = {} # 构建数据中所有标记的索引。
for sample in samples:
for word in sample.split():
if word not in token_index:
token_index[word] = len(token_index) + 1 # 为每个唯一单词指定一个唯一索引。注意，没有为索引编号0指定单词。
max_length = 10 # 对样本进行分子。只考虑每个样本前max_length个单词。
results = np.zeros(shape=(len(samples),
max_length,
max(token_index.values()) + 1)) # 将结果保存在results中。
for i, sample in enumerate(samples):
for j, word in list(enumerate(sample.split()))[:max_length]:
index = token_index.get(word)
results[i, j, index] = 1.
print(results)[[[0. 1. 0. 0. 0. 0. 0. 0. 0. 0. 0.]
[0. 0. 1. 0. 0. 0. 0. 0. 0. 0. 0.]
[0. 0. 0. 1. 0. 0. 0. 0. 0. 0. 0.]
[0. 0. 0. 0. 1. 0. 0. 0. 0. 0. 0.]
[0. 0. 0. 0. 0. 1. 0. 0. 0. 0. 0.]
[0. 0. 0. 0. 0. 0. 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. 1. 0. 0. 0. 0. 0. 0. 0. 0. 0.]
[0. 0. 0. 0. 0. 0. 0. 1. 0. 0. 0.]
[0. 0. 0. 0. 0. 0. 0. 0. 1. 0. 0.]
[0. 0. 0. 0. 0. 0. 0. 0. 0. 1. 0.]
[0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 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.]]]
字符级的one-hot编码：
import string
import numpy as np
samples = ['The cat sat on the mat.', 'The dog ate my homework.']
characters = string.printable
token_index = dict(zip(characters, range(1, len(characters) + 1)))
max_length = 50
results = np.zeros((len(samples), max_length, max(token_index.values()) + 1))
for i, sample in enumerate(samples):
for j, character in enumerate(sample[:max_length]):
index = token_index.get(character)
results[i, j, index] = 1.
print(results)
print(results.shape)[[[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.]]]
(2, 50, 101)
Keras的内置函数可以对原始文本数据进行单词级或字符级的one-hot编码，它们实现了许多重要的特性，比如从字符串中去除特殊字符、只考虑数据集中前N个最常见的单词。
用Keras实现单词级的one-hot编码：
from keras.preprocessing.text import Tokenizer
samples = ['The cat sat on the mat.', 'The dog ate my homework.']
tokenizer = Tokenizer(num_words=1000) # 创建一个分词器（tokenizer)，设置为只考虑前1000个最常见的单词。
tokenizer.fit_on_texts(samples) # 构建单词索引。
sequences = tokenizer.texts_to_sequences(samples) # 将字符串转换为整数索引组成的列表
one_hot_results = tokenizer.texts_to_matrix(samples, mode='binary') # 也可以直接得到one-hot二进制表示，这个分词器也支持除one-hot编码外的其他向量化模式
word_index = tokenizer.word_index # 找回单词索引
print('Found %s unique tokens.' % len(word_index))Found 9 unique tokens.one-hot编码的一种变体是所谓的one-hot散列技巧，如果词表中唯一标记的数量太大而无法直接处理，就可以使用这种技巧。这种方法没有为每个单词显示分配一个索引并将这些索引保存在一个字典中，而是将单词散列编码为固定长度的向量，通常用一个非常简单的散列函数来实现。这种方法的主要优点在于，它避免了维护一个显示的单词索引，从而节省内存并允许数据的在线编码（在读取完所有数据之前，你就可以立刻生成标记向量）。这种方法有一个缺点，就是可能会出现散列冲突，即两个不同的单词可能会具有相同的散列值，随后任何机器学习模型观察这些散列值，都无法区分它们所对应的单词。如果散列空间的维度远大于需要散列的唯一标记的个数，散列冲突的可能性会减小。
使用散列技巧的单词级的one-hot编码（简单示例）：
samples = ['The cat sat on the mat.', 'The dog ate my homework.']
dimensionality = 1000 # 将单词保存为长度为1000的向量，如果单词数量接近1000个（或更多），那么会遇到很多散列冲突，这会降低这种编码方法的准确性。
max_length = 10
results = np.zeros((len(samples), max_length, dimensionality))
for i, sample in enumerate(samples):
for j, word in list(enumerate(sample.split()))[:max_length]:
index = abs(hash(word) % dimensionality) # 将单词散列为0~1000范围内的一个随机整数索引。
results[i, j, index] = 1.
print(results)[[[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.]]]6.1.2 使用词嵌入
将单词与向量相关联还有另一种常用的强大方法，就是使用密集的词向量，也叫词嵌入。one-hot编码得到的向量是二进制的、稀疏的（绝大部分元素都是0）、维度很高的（维度大小等于词表中的单词个数），而词嵌入是低维的浮点数向量（即密集向量，与稀疏向量相对）。与one-hot编码得到的词向量不同，词嵌入是从数据中学习得到的。
获取词嵌入有两种方法：
（1）在完成主任务（比如文档分类或情感预测）的同时学习词嵌入。在这种情况下，一开始是随机的词向量，然后对这些词向量进行学习，其学习方式与学习神经网络的权重相同。
（2）在不同于待解决的机器学习任务上预计算好词嵌入，然后将其加载到模型中。这些词嵌入叫作预训练词嵌入。
1.利用Embedding层学习词嵌入
要将一个词与一个密集向量相关联，最简单的方法就是随机选择向量。这种方法的问题在于，得到的嵌入空间没有任何结构。深度神经网络很难对杂乱的、非结构化的嵌入空间进行学习。
词向量之间的几何关系应该表示这些词之间的语义关系，词嵌入的作用应该是将人类的语言映射到几何空间中。一般来说，任意两个词向量之间的几何距离应该和这两个词的语义距离有关（表示不同事物的词被嵌入到相隔很远的点，而相关的词则更加靠近）。
在真实的词嵌入空间中，常见的有意义的几何变换的例子包括“性别”向量和“复数”向量。
有没有一个理想的词嵌入空间，可以完美地映射人类语言，并可用于所有自然语言处理任务？可能有，但我们尚未发现。此外，也不存在人类语言这种东西。世界上有许多种不同的语言，而且它们不是同构的，因为语言是特定文化和特定环境的反射。但从更实际的角度来说，一个好的词嵌入空间在很大程度上取决于你的任务。英语电影评论情感分析模型的完美词嵌入空间，可能不同于英语法律文档分类模型的完美词嵌入空间，因为某些语义关系的重要性因任务而异。
因此，合理的做法是对每个新任务都学习一个新的嵌入空间。
将一个Embedding层实例化：
from keras.layers import Embedding
embedding_layer = Embedding(1000, 64) # Embedding层至少需要两个参数：标记的个数（这里是1000，即最大单次索引+1）和嵌入的维度（这里是64）。
Embedding层实际上是一种字典查找。
将一个Embedding层实例化时，它的权重（即标记向量的内部字典）最开始是随机的，与其它层一样。在训练过程中，利用反向传播来逐渐调节这些词向量，改变空间结构以便下有模型可以利用。一旦训练完成，嵌入空间将会展示大量结构，这种结构专门针对训练模型所要解决的问题。
加载IMDB数据，准备用于Embedding层：
from keras.datasets import imdb
from keras import preprocessing
max_features = 10000 # 作为特征的单词个数
maxlen = 20 # 在这么多单词后截断文本（这些单词都属于前max_features个最常见的单词）
(x_train, y_train), (x_test, y_test) = imdb.load_data(
num_words=max_features
)
x_train = preprocessing.sequence.pad_sequences(x_train, maxlen=maxlen)
x_test = preprocessing.sequence.pad_sequences(x_test, maxlen=maxlen)在IMDB数据上使用Embedding层和分类器：
from keras.models import Sequential
from keras.layers import Flatten, Dense, Embedding
model = Sequential()
model.add(Embedding(10000, 8, input_length=maxlen)) # 指定Embedding层的最大输入长度，以便后面将嵌入输入展平。Embedding层激活的形状为（samples, maxlen, 8）
model.add(Flatten)
model.add(Dense(1, activation='sigmoid')) # 在上面添加分类器
model.compile(optimizer='rmsprop', loss='binary_crossentropy', metrics=['acc'])
model.summary()
history = model.fit(x_train, y_train,
epochs=10,
batch_size=32,
validation_split=0.2)
2.使用预训练的词嵌入
你可以从预计算的嵌入空间中加载嵌入向量，而不是在解决问题的同时学习词嵌入。在自然语言处理中使用预训练的词嵌入，其背后的原理与在图像分类中使用预训练的卷积神经网络是一样的：没有足够的数据来自己学习真正强大的特征，但你需要的特征应该是非常通用的，比如常见的视觉特征或语义特征。在这种情况下，重复使用在其他问题上学到的特征，这种做法是有道理的。
这种词嵌入通常是利用词频统计计算得出的（观察哪些词共同出现在句子或文档中），用到的技术很多，有些涉及神经网络，有些则不涉及。有许多预计算的词嵌入数据库，你都可以下载并在Keras的Embedding层中使用。
6.1.3 整合在一起：从原始文本到词嵌入
1.下载IMDB数据的原始文本
import os
imdb_dir = r'E:\aclImdb\aclImdb'
train_dir = os.path.join(imdb_dir, 'train')
labels = []
texts = []
for label_type in ['neg', 'pos']:
dir_name = os.path.join(train_dir, label_type)
for fname in os.listdir(dir_name):
if fname[-4:] == '.txt':
f = open(os.path.join(dir_name, fname))
texts.append(f.read())
f.close()
if label_type == 'neg':
labels.append(0)
else:
labels.append(1)
2.对数据进行分词
对IMDB原始数据的文本进行分词：
from keras.preprocessing.text import Tokenizer
from keras.preprocessing.sequence import pad_sequences
import numpy as np
maxlen = 100 # 在100个单词后截断评论
training_samples = 200 # 在200个样本上训练
validation_samples = 10000 # 在10000个样本上验证
max_words = 10000 # 只考虑数据集中前10000个最常见的单词
tokenizer = Tokenizer(num_words=max_words)
tokenizer.fit_on_texts(texts)
sequences = tokenizer.texts_to_sequences(texts)
word_index = tokenizer.word_index
print('Found %s unique tokens.' % len(word_index))
data = pad_sequences(sequences, maxlen=maxlen)
labels = np.asarray(labels)
print('Shape of data tensor:', data.shape)
print('Shape of label tensor:', labels.shape)
indices = np.arange(data.shape[0]) # 将数据划分为训练集和验证集，但首先要打乱数据，因为一开始数据中的样本是排好序的（所有负面评论都在前面，然后是所有正面评论）
np.random.shuffle(indices)
data = data[indices]
labels = labels[indices]
x_train = data[:training_samples]
y_train = labels[:training_samples]
x_val = data[training_samples: training_samples + validation_samples]
y_val = labels[training_samples: training_samples + validation_samples]3.下载GloVe词嵌入
https://nlp.stanford.edu/projects/glove
4.对嵌入进行预处理
解析GloVe词嵌入文件：
glove_dir = r'E:\glove.6B'
embeddings_index = {}
f = open(os.path.join(glove_dir, 'glove.6B.100d.txt'), encoding='UTF-8')
for line in f:
values = line.split()
word = values[0]
coefs = np.asarray(values[1:], dtype='float32')
embeddings_index[word] = coefs
f.close()
print('Found %s word vectors.' % len(embeddings_index))Found 88583 unique tokens.
Shape of data tensor: (25000, 100)
Shape of label tensor: (25000,)
Found 400000 word vectors.注意：在这里可能会遇到编码不对的问题，只需在打开文件的时候声明
encoding='UTF-8'
准备GloVe词嵌入矩阵：
embedding_dim = 100
embedding_matrix = np.zeros((max_words, embedding_dim))
for word, i in word_index.items():
if i < max_words:
embedding_vector = embeddings_index.get(word)
if embedding_vector is not None:
embedding_matrix[i] = embedding_vector # 嵌入索引中找不到的词，其嵌入向量全为05.定义模型
模型定义：
from keras.models import Sequential
from keras.layers import Embedding, Flatten, Dense
model = Sequential()
model.add(Embedding(max_words, embedding_dim, input_length=maxlen))
model.add(Flatten())
model.add(Dense(32, activation='relu'))
model.add(Dense(1, activation='sigmoid'))
model.summary()
6.在模型中加载GloVe嵌入
将预训练的词嵌入加载到Embedding层中：
model.layers[0].set_weights([embedding_matrix])
model.layers[0].trainable = False7.训练模型与评估模型
训练与评估：
model.compile(optimizer='rmsprop',
loss='binary_crossentropy',
metrics=['acc'])
history = model.fit(x_train, y_train,
epochs=10,
batch_size=32,
validation_data=(x_val, y_val))
model.save_weoghts('pre_trained_glove_model.h5')绘制结果：
import matplotlib.pyplot as plt
acc = history.history['acc']
val_acc = history.history['val_acc']
loss = history.history['loss']
val_loss = history.history['val_loss']
epochs = range(1, len(acc) + 1)
plt.plot(epochs, acc, 'bo', label='Training acc')
plt.plot(epochs, val_acc, 'b', label='Validation acc')
plt.title('Training and validation accuracy')
plt.legend()
plt.figure()
plt.plot(epochs, loss, 'bo', label='Training loss')
plt.plot(epochs, val_loss, 'b', label='Validation loss')
plt.title('Training and validation loss')
plt.legend()
plt.show()
在不使用预训练词嵌入的情况下，训练相同的模型：
from keras.models import Sequential
from keras.layers import Embedding, Flatten, Dense
model = Sequential()
model.add(Embedding(max_words, embedding_dim, input_length=maxlen))
model.add(Flatten())
model.add(Dense(32, activation='relu'))
model.add(Dense(1, activation='sigmoid'))
model.summary()
model.compile(optimzier='rmsprop',
loss='binary_crossentropy',
metrics=['acc'])
history = model.fit(x_train, y_train,
epochs=10,
batch_size=32,
validation_data=(x_val, y_val))
对测试集数据进行分词：
test_dir = os.path.join(imdb_dir, 'test')
labels = []
texts = []
for label_type in ['neg', 'pos']:
dir_name = os.path.join(test_dir, label_type)
for fname in sorted(os.listdir(dir_name)):
if fname[-4:] == '.txt':
f = open(os.path.join(dir_name, fname))
texts.append(f.read())
f.close()
if label_type == 'neg':
labels.append(0)
else:
labels.append(1)
sequences = tokenizer.texts_to_sequences(texts)
x_test = pad_sequences(sequences, maxlen=maxlen)
y_test = np.asarray(labels)
在测试集上评估模型：
model.load_weights('pre_trained_glove_model.h5')
model.evaluate(x_test, y_test)6.1.4 小结
现在你已经学会了下列内容：
1.将原始文本转换为神经网络能够处理的格式；
2.使用Keras模型的Embedding层来学习针对特定任务的标记嵌入；
3.使用预训练词嵌入在小型自然语言处理问题上获得额外的性能提升。
6.2 理解循环神经网络
目前你见过的所有神经网络（比如密集连接网络和卷积神经网络）都有一个主要特点，那就是它们都没有记忆。它们单独处理每个输入，在输入与输入之间没有保存任何状态。对于这样的网络，要想处理数据点的序列或时间序列，你需要向网络同时展示整个序列，即将序列转换成单个数据点。这种网络叫作前馈网络。
生物智能以渐进的方式处理信息，同时保存一个关于所处理内容的内部模型，这个模型是根据过去的信息构建的，并随着信息的进入而不断更新。
循环神经网络（RNN）采用同样的原理，不过是一个极其简化的版本：它处理序列的方式是，遍历所有序列元素，并保存一个状态，其中包含与已查看内容相关的信息。实际上，RNN是一类具有内部环的神经网络，在处理两个不同的独立序列之间，RNN状态会被重置，因此，你仍可以将一个序列看作单个数据点，即网络的单个输入。真正改变的是，数据点不再是在单个步骤中进行处理，相反，网络内部会对序列元素进行遍历。
RNN伪代码：
state_t = 0 # t时刻的状态
for input_t in input_sequence: # 对序列元素进行遍历
output_t = f(input_t, state_t)
state_t = output_t # 前一次的输出变成下一次迭代的状态更详细的RNN伪代码：
state_t = 0
for input_t in input_sequence:
output_t = activation(dot(W, input_t) + dot(U, state_t) + b)
state_t = output_t简单RNN的Numpy实现：
import numpy as np
timesteps = 100 # 输入序列的时间步数
input_features = 32 # 输入特征空间的维度
output_features = 64 # 输出特征空间的维度
inputs = np.random.random((timesteps, input_features)) # 输入数据：随机噪声，仅作为示例
state_t = np.zeros((output_features,)) # 初始状态：全零向量
# 创建随机的权重矩阵
W = np.random.random((output_features, input_features))
U = np.random.random((output_features, output_features))
b = np.random.random(output_features,)
successive_outputs = []
for input_t in inputs: # input_t是形状为（input_features,）的向量
output_t = np.tanh(np.dot(W, input_t) + np.dot(U, state_t) + b) # 由输入和当前状态（前一个输出）计算得到当前输出
successive_outputs.append(output_t) # 将这个输出保存到一个列表中
state_t = output_t # 更新网络的状态，用于下一个时间同步
final_output_sequence = np.stack(successive_outputs, axis=0) # 最终输出是一个形状为（timesteps, output_features）的二维张量
print(final_output_sequence)[[0.99999996 0.9999983 0.9999998 ... 0.99999975 0.99999997 0.99999996]
[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. ]]
output_t = np.tanh(np.dot(W, input_t) + np.dot(U, state_t) + b)
6.2.1 Keras中的循环层
SimpleRNN层能够像其他Keras层一样处理序列批量，而不是像Numpy示例那样只能处理单个序列。因此，它接受形状为(batch_size, timesteps, input_features)的输入，而不是(timesteps, input_features)。
Model: "sequential"
_________________________________________________________________
Layer (type) Output Shape Param #
=================================================================
embedding (Embedding) (None, None, 32) 320000
simple_rnn (SimpleRNN) (None, 32) 2080
=================================================================
Total params: 322,080
Trainable params: 322,080
Non-trainable params: 0
_________________________________________________________________
Nonefrom keras.models import Sequential
from keras.layers import Embedding, SimpleRNN
model = Sequential()
model.add(Embedding(10000, 32))
model.add(SimpleRNN(32, return_sequences=True))
print(model.summary())
Model: "sequential"
_________________________________________________________________
Layer (type) Output Shape Param #
=================================================================
embedding (Embedding) (None, None, 32) 320000
simple_rnn (SimpleRNN) (None, None, 32) 2080
=================================================================
Total params: 322,080
Trainable params: 322,080
Non-trainable params: 0
_________________________________________________________________
Nonefrom keras.models import Sequential
from keras.layers import Embedding, SimpleRNN
model = Sequential()
model.add(Embedding(10000, 32))
model.add(SimpleRNN(32, return_sequences=True))
model.add(SimpleRNN(32, return_sequences=True))
model.add(SimpleRNN(32, return_sequences=True))
model.add(SimpleRNN(32))
print(model.summary())
Model: "sequential"
_________________________________________________________________
Layer (type) Output Shape Param #
=================================================================
embedding (Embedding) (None, None, 32) 320000
simple_rnn (SimpleRNN) (None, None, 32) 2080
simple_rnn_1 (SimpleRNN) (None, None, 32) 2080
simple_rnn_2 (SimpleRNN) (None, None, 32) 2080
simple_rnn_3 (SimpleRNN) (None, 32) 2080
=================================================================
Total params: 328,320
Trainable params: 328,320
Non-trainable params: 0
_________________________________________________________________
None准备IMDB数据：
from keras.datasets import imdb
from keras.preprocessing import sequence
max_features = 10000 # 作为特征的单词个数
maxlen = 500 # 在这么多单词之后截断文本（这些单词都属于前max_features个最常见的单词）
batch_size = 32
print('Loading data...')
(input_train, y_train), (input_test, y_test) = imdb.load_data(
num_words=max_features
)
print(len(input_train), 'train sequences')
print(len(input_test), 'test sequences')
print('Pad sequences (samples x time)')
input_train = sequence.pad_sequences(input_train, maxlen=maxlen)
input_test = sequence.pad_sequences(input_test, maxlen=maxlen)
print('input_train shape:', input_train.shape)
print('input_test shape:', input_test.shape)Loading data...
25000 train sequences
25000 test sequences
Pad sequences (samples x time)
input_train shape: (25000, 500)
input_test shape: (25000, 500)用Embedding层和SimpleRNN层来训练：
# 绘制结果
import matplotlib.pyplot as plt
acc = history.history['acc']
val_acc = history.history['val_acc']
loss = history.history['loss']
val_loss = history.history['val_loss']
epochs = range(1, len(acc) + 1)
plt.plot(epochs, acc, 'bo', label='Training acc')
plt.plot(epochs, val_acc, 'b', lable='Validation acc')
plt.title('Training and validation accuracy')
plt.legend()
plt.figure()
plt.plot(epochs, loss, 'bo', label='Training loss')
plt.plot(epochs, val_loss, 'b', label='Validation loss')
plt.title('Training and validation loss')
plt.legend()
plt.show()
暂停更新这本书的读书笔记，昨天遇到的问题今天又出现了，烦死。。。。
AttributeError: module 'tensorflow.compat.v2.__internal__.distribute' has no attribute 'strategy_supports_no_merge_call'有木有大佬能够解答一下。。。。。。求助ing