• In the town of Athy one Jeremy Lanigan

• Battered away til he hadnt a pound.

• His father died and made him a man again

• Left him a farm and ten acres of ground.

• He gave a grand party for friends and relations

• Who didnt forget him when come to the wall,

• And if youll but listen Ill make your eyes glisten

• Of the rows and the ructions of Lanigan’s Ball.

• Myself to be sure got free invitation,

• For all the nice girls and boys I might ask,

• And just in a minute both friends and relations

• Were dancing round merry as bees round a cask.

• Judy ODaly, that nice little milliner,

• She tipped me a wink for to give her a call,

• And I soon arrived with Peggy McGilligan

• Just in time for Lanigans Ball.

创建一个包含所有文本的字符串，并将其设置为您的数据。用于\n换行符。然后可以像这样轻松加载和标记这个语料库：

tokenizer = Tokenizer()

data="In the town of Athy one Jeremy Lanigan \n Battered away ... ..."
corpus = data.lower().split("\n")

tokenizer.fit_on_texts(corpus)
total_words = len(tokenizer.word_index) + 1

这个过程的结果是用它们的标记值替换单词，如图 8-1所示。

图 8-1。标记一个句子

为了训练预测模型，我们应该在这里采取进一步的步骤——将句子分成多个更小的序列，例如，我们可以有一个序列由前两个标记组成，另一个序列由前三个标记组成，等等。（图 8 -2）。

图 8-2。将一个序列转换为多个输入序列

 为此，您需要遍历语料库中的每一行并将其转换为使用的标记列表 texts_to_sequences. 然后，您可以通过遍历每个标记并列出所有标记来拆分每个列表。

这是代码：

input_sequences = []
for line in corpus:
    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)

print(input_sequences[:5])

一旦你有了这些输入序列，你就可以将它们填充成规则的形状。我们将使用预填充（图 8-3）。

为此，您需要在输入序列中找到最长的句子，并将所有内容填充到该长度。这是代码：

max_sequence_len = max([len(x) for x in input_sequences])

input_sequences = np.array(pad_sequences(input_sequences, 
                            maxlen=max_sequence_len, padding='pre'))

最后，一旦有了一组填充输入序列，就可以将它们拆分为特征和标签，其中标签只是输入序列中的最后一个标记（图 8-4）。

图 8-4。将填充序列转换为特征 (x) 和标签 (y)

训练神经网络时，您需要将每个特征与其对应的标签相匹配。因此，例如，[0 0 0 0 4 2 66 8 67 68 69] 的标签将是 [70]。

下面是将标签与输入序列分开的代码：

xs, labels = input_sequences[:,:-1],input_sequences[:,-1]

接下来，您需要对标签。现在它们只是标记——例如，图 8-4顶部的数字 2 。但是如果你想在分类器中使用一个标记作为标签，它必须被映射到一个输出神经元。因此，如果你要对n 个词进行分类，每个词都是一个类，你需要有n 个神经元。这就是控制词汇量很重要的地方，因为你拥有的单词越多，你需要的类就越多。记得回到第2章和第3章当您使用 Fashion MNIST 数据集对时尚商品进行分类时，您有 10 种类型的服装？这要求你在输出层中有 10 个神经元。在这种情况下，如果你想预测最多 10,000 个词汇怎么办？您需要一个包含 10,000 个神经元的输出层！

此外，您需要one-hot 对你的标签进行编码，使它们与神经网络的所需输出相匹配。考虑图 8-4。如果向神经网络输入由一系列 0 后跟一个 4 组成的输入 X，您会希望预测为 2，但网络如何传递它是通过具有 vocabulary_size 神经元的输出层，其中第二个神经元概率最高。

要将您的标签编码为一组 Y，然后您可以使用它来训练，您可以使用该to_categorical实用程序tf.keras：

ys = tf.keras.utils.to_categorical(labels, num_classes=total_words)

您可以在图 8-5中直观地看到这一点。

图 8-5。One-hot编码标签

这是一个非常稀疏的表示，如果你有很多训练数据和很多潜在的词，它会很快吃掉内存！假设您有 100,000 个训练句子，词汇量为 10,000 个单词——您需要 1,000,000,000 个字节来保存标签！但如果我们要对单词进行分类和预测，这就是我们必须设计网络的方式。

model = Sequential()
model.add(Embedding(total_words, 8))
model.add(Bidirectional(LSTM(max_sequence_len-1)))
model.add(Dense(total_words, activation='softmax'))

model.compile(loss='categorical_crossentropy', 
               optimizer='adam', metrics=['accuracy'])

你会首先创建一个称为种子文本的短语。这是网络将基于其生成的所有内容的初始表达式。它将通过预测下一个词来做到这一点。

seed_text = "in the town of athy"

 接下来，您需要使用 texts_to_sequences. 这将返回一个数组，即使只有一个值，所以取该数组中的第一个元素：

token_list = tokenizer.texts_to_sequences([seed_text])[0]

然后您需要填充该序列以使其与用于训练的数据具有相同的形状：

token_list = pad_sequences([token_list], 
                            maxlen=max_sequence_len-1, padding='pre')

现在您可以通过调用预测此标记列表的下一个单词 model.predict在令牌列表上。这将返回语料库中每个单词的概率，因此将结果传递给 np.argmax得到最有可能的：

predicted = np.argmax(model.predict(token_list), axis=-1)
print(predicted)

'town': 66, 'athy': 67, 'one': 68, 'jeremy': 69, 'lanigan': 70,

for word, index in tokenizer.word_index.items():
    if index == predicted:
        print(word)
        break

在在上一节中，您了解了如何使用模型预测给定种子文本的下一个单词。要让神经网络现在创建新文本，您只需重复预测，每次都添加新词。

例如，早些时候当我使用短语“sweet jeremy saw dublin”时，它预测下一个词是“then”。您可以在此基础上通过将“then”附加到种子文本以获得“sweet jeremy saw dublin then”并获得另一个预测。重复此过程将为您提供 AI 创建的文本字符串。

这是上一节中多次执行此循环的更新代码，次数由 next_words范围：

seed_text = "sweet jeremy saw dublin"
next_words=10

for _ in range(next_words):
    token_list = tokenizer.texts_to_sequences([seed_text])[0]
    token_list = pad_sequences([token_list], 
 maxlen=max_sequence_len-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

print(seed_text)

这将最终创建一个像这样的字符串：

sweet jeremy saw dublin then got there as me me a call doing me

扩展数据集

这您用于硬编码数据集的相同模式可以扩展为非常简单地使用文本文件。我托管了一个文本文件，其中包含大约 1,700 行文本，这些文本是从您可以用于实验的大量歌曲中收集而来的。稍微修改一下，您就可以使用它来代替单一的硬编码歌曲。

要在 Colab 中下载数据，请使用以下代码：

!wget --no-check-certificate \
    https://storage.googleapis.com/laurencemoroney-blog.appspot.com/ \
    irish-lyrics-eof.txt-O /tmp/irish-lyrics-eof.txt

然后你可以像这样简单地将文本从它加载到你的语料库中：

data = open('/tmp/irish-lyrics-eof.txt').read()
corpus = data.lower().split("\n")

您的其余代码将无需修改即可工作！

对其进行一千个时期的训练可以使您获得大约 60% 的准确度，并且曲线变平（图 8-7）。

图 8-7。在更大的数据集上训练

再次尝试“in the town of athy”这个短语会得到“one”的预测，但这次的概率只有 40%。

对于“sweet jeremy saw dublin”，预测的下一个词是“drawn”，概率为 59%。预测接下来的 10 个单词会产生：

sweet jeremy saw dublin drawn and fondly i am dead and the parting graceful

它看起来好多了！但是我们可以进一步改进它吗？

更改模型架构

一改进模型的方法是使用多个堆叠 LSTM 来更改其架构。这非常简单 - 只需确保您设置return_sequences为True其中的第一个。这是代码：

model = Sequential()
model.add(Embedding(total_words, 8))
model.add(Bidirectional(LSTM(max_sequence_len-1, return_sequences='True')))
model.add(Bidirectional(LSTM(max_sequence_len-1)))
model.add(Dense(total_words, activation='softmax'))
model.compile(loss='categorical_crossentropy', optimizer='adam', 
			  metrics=['accuracy'])
history = model.fit(xs, ys, epochs=1000, verbose=1)

您可以在图 8-8中看到这对训练一千个时期的影响。它与之前的曲线没有显着差异。

图 8-8。添加第二个 LSTM 层

 当使用与之前相同的短语进行测试时，这次我以 51% 的概率得到了“in the town of athy”之后的“more”作为下一个词，而在“sweet jeremy saw dublin”之后我得到了“cailín”（盖尔语“女孩”一词）的概率为 61%。同样，当预测更多单词时，输出很快就会变成乱码。

这里有些例子：

sweet jeremy saw dublin cailín loo ra fountain plundering that fulfill
you mccarthy you mccarthy down

you know nothing jon snow johnny cease and she danced that put to smother well
i must the wind flowers
dreams it love to laid ned the mossy and night i weirs

如果您得到不同的结果，请不要担心——您没有做错任何事情，但神经元的随机初始化会影响最终分数。

改进数据

有您可以使用一个小技巧来扩展此数据集的大小而无需添加任何新歌曲，称为 开窗数据。现在，每首歌曲中的每一行都作为一行读取，然后转换为输入序列，如图 8-2 所示。虽然人类逐行阅读歌曲是为了听到押韵和韵律，但模型不必这样做，尤其是在使用双向 LSTM 时。

因此，与其采用“在 Athy 镇，一个 Jeremy Lanigan”这一行，而不是处理它，然后移动到下一行（“Battered away till he hadn't a pound”）并处理它，我们可以处理所有这些行是一个长的、连续的文本。然后，我们可以创建一个包含n 个单词的文本的“窗口”，对其进行处理，然后将窗口向前移动一个单词以获得下一个输入序列（图 8-9）。

图 8-9。一个移动的单词窗口

 在这种情况下，可以以增加输入序列数量的形式产生更多的训练数据。在整个文本语料库中移动窗口将为我们提供 (( number_of_words – window_size ) × window_size ) 个我们可以用来训练的输入序列。

代码非常简单——在加载数据时，我们可以根据语料库中的单词动态创建它们，而不是将每首歌的歌词分割成一个“句子”：

window_size=10
sentences=[]
alltext=[]
data = open('/tmp/irish-lyrics-eof.txt').read()
corpus = data.lower()
words = corpus.split(" ")
range_size = len(words)-max_sequence_len
for i in range(0, range_size):
    thissentence=""
    for word in range(0, window_size-1):
        word = words[i+word]
        thissentence = thissentence + word
        thissentence = thissentence + " "
    sentences.append(thissentence)

在这种情况下，因为我们不再有句子而且我们正在创建与移动窗口，max_sequence_len就是窗口的大小。读取完整文件，将其转换为小写，然后使用字符串拆分将其拆分为单词数组。然后代码循环遍历单词并从当前索引到当前索引加上窗口大小的每个单词造句，将每个新构造的句子添加到句子数组中。

训练时，您会注意到额外的数据使每个时期的速度慢得多，但结果得到了极大的改善，并且生成的文本变得乱码的速度也慢得多。

这是一个引起我注意的例子——尤其是最后一行！

• you know nothing, jon snow is gone

• and the young and the rose and wide

• to where my love i will play

• the heart of the kerry

• the wall i watched a neat little town

有许多您可以尝试调整超参数。改变窗口大小会改变训练数据的数量——较小的窗口大小可以产生更多的数据，但是给标签的单词会更少，所以如果你把它设置得太小，你最终会得到无意义的诗歌。您还可以更改嵌入的维度、LSTM 的数量或用于训练的词汇的大小。鉴于百分比准确度并不是最好的衡量标准——你会想要对诗歌的“意义”进行更主观的检查——没有硬性规定可用于确定你的模型是否“好”或不。

例如，当我尝试使用 6 的窗口大小时，将嵌入的维数增加到 16，将 LSTM 的数量从窗口大小（应该是 6）更改为 32，并提高 Adam 的学习率优化器，我得到了一条漂亮、平滑的学习曲线（图 8-10），一些诗歌开始变得更有意义了。

图 8-10。调整超参数的学习曲线

当使用“sweet jeremy saw dublin”作为种子时（记住，种子中的所有词都在语料库中），我得到了这首诗：

• sweet jeremy saw dublin

• whack fol

• all the watch came

• and if ever you love get up from the stool

• longs to go as i was passing my aged father

• if you can visit new ross

• gallant words i shall make

• such powr of her goods

• and her gear

• and her calico blouse

• she began the one night

• rain from the morning so early

• oer railroad ties and crossings

• i made my weary way

• through swamps and elevations

• my tired feet

• was the good heavens

虽然“whack fol”这个短语对很多读者来说可能没有意义，但它在一些爱尔兰歌曲中很常见，有点像“la la la”或“doobie-doobie-doo”。我真正喜欢的是后面的一些短语如何保持某种意义，比如“她的物品和装备以及她的印花布衬衫的力量”——但这可能是由于过度拟合已经存在的短语语料库中的歌曲。例如，从“oer railroad ties...”到“my tired feet”的句子直接取自语料库中一首名为“The Lakes of Pontchartrain”的歌曲。如果您遇到这样的问题，最好降低学习率并减少 LSTM 的数量。但最重要的是，尝试并享受乐趣！

基于字符的编码

为了前几章我们一直在研究使用基于词的编码的 NLP。我发现这更容易上手，但在生成文本时，您可能还需要考虑基于字符的编码，因为语料库中唯一字符的数量往往比唯一单词的数量少得多。因此，您的输出层中可以有更少的神经元，并且您的输出预测分布在更少的概率上。例如，在查看莎士比亚全集的数据集时，您会看到整个集合中只有 65 个不同的字符。因此，当您进行预测时，您不会像在爱尔兰歌曲数据集中那样查看 2,700 个单词中下一个单词的概率，而是只查看 65 个单词。这会使您的模型更简单一些！

字符编码的另一个好处是标点字符也包括在内，因此可以预测换行符等。例如，当我使用在莎士比亚语料库上训练的 RNN 来预测我最喜欢的《权力的游戏》台词之后的文本时，我得到：

• YGRITTE:

• You know nothing, Jon Snow.

• Good night, we’ll prove those body’s servants to

• The traitor be these mine:

• So diswarl his body in hope in this resceins,

• I cannot judg appeal’t.

• MENENIUS:

• Why, ’tis pompetsion.

• KING RICHARD II:

• I think he make her thought on mine;

• She will not: suffer up thy bonds:

• How doched it, I pray the gott,

• We’ll no fame to this your love, and you were ends

 她认定他是叛徒并想把他绑起来（“驱散他的身体”）有点酷，但我不知道“resceins”是什么意思！如果你看过这部剧，就会发现这是情节的一部分，所以也许莎士比亚在没有意识到的情况下有所作为！

当然，我确实认为在使用像莎士比亚的文本作为我们的训练数据时我们往往会更宽容一点，因为这种语言已经有点陌生了。

与爱尔兰歌曲模型一样，输出确实会很快退化为无意义的文本，但玩起来仍然很有趣。要亲自尝试，您可以查看Colab。

概括

在本章中，我们探讨了如何使用经过训练的基于 LSTM 的模型进行基本文本生成。您了解了如何将文本拆分为训练特征和标签，使用单词作为标签，并创建一个模型，在给定种子文本时，该模型可以预测下一个可能的单词。您对此进行了迭代以改进模型以获得更好的结果，探索了传统爱尔兰歌曲的数据集。您还通过使用莎士比亚文本的示例了解了如何通过基于字符的文本生成来潜在地改进这一点。希望这是对机器学习模型如何合成文本的有趣介绍！