从零开始构建文本生成 AI 模型

在连续之前，解释一点：这篇文章的紧张目的是为了先容天生式AI的基本观点和演习步骤。
通过供应大略的代码示例，旨在帮助读者建立对天生式 AI 开拓过程的初步理解和认识。
请把稳，这里展示的代码是为了演示目的而简化的，旨在揭示背后的核心事理。
希望读完这篇文章后，能帮读者对如何从头开始构建这样的模型有一个基本的理解。

第一步：设置环境

首先，须要安装 PyTorch。
PyTorch 是一个盛行的开源机器学习库，特殊适用于深度学习和神经网络。

pip install torch第二步：准备数据

为了大略起见，我们利用一个小文本语料库，这是模型演习的根本数据。
示例中利用了简短的文本字符串。
在真实场景中，会利用更大的数据集。

text = "This is a simple demo text for training our RNN model."

现在，我们须要创建字符到整数的映射（反之亦然），由于神经网络利用数值数据。
神经网络不能直接处理文本数据，因此须要将每个字符映射到一个整数。
char2int 和 int2char 是用于字符和整数之间相互转换的字典。

chars = tuple(set(text))int2char = dict(enumerate(chars))char2int = {ch: ii for ii, ch in int2char.items()}# 编码文本，将原始文本字符串转换成整数序列，以便能被模型处理。
encoded = [char2int[ch] for ch in text]第三步：定义模型

我们将利用 PyTorch 定义一个大略的 RNN 模型。

CharRNN 类：这是一个继续自 nn.Module 的类，用于定义循环神经网络模型。
LSTM 层：self.lstm 定义了 LSTM (Long Short-Term Memory) 层，这是一种分外类型的 RNN，优于普通 RNN，由于它可以避免长期依赖问题。
Dropout 层：self.dropout 用于防止过拟合，通过随机丢弃一些神经元输出。
全连接层：self.fc 是一个全连接层，用于将 LSTM 的输出转换回字符空间。

import torchimport torch.nn as nnclass CharRNN(nn.Module): def __init__(self, tokens, n_hidden=256, n_layers=2, drop_prob=0.5): super(CharRNN, self).__init__() self.drop_prob = drop_prob self.n_layers = n_layers self.n_hidden = n_hidden self.chars = tokens self.lstm = nn.LSTM(len(self.chars), n_hidden, n_layers, dropout=drop_prob, batch_first=True) self.dropout = nn.Dropout(drop_prob) self.fc = nn.Linear(n_hidden, len(self.chars)) def forward(self, x, hidden): r_output, hidden = self.lstm(x, hidden) out = self.dropout(r_output) out = out.contiguous().view(-1, self.n_hidden) out = self.fc(out) return out, hidden def init_hidden(self, batch_size): weight = next(self.parameters()).data hidden = (weight.new(self.n_layers, batch_size, self.n_hidden).zero_(), weight.new(self.n_layers, batch_size, self.n_hidden).zero_()) return hidden第四步：演习模型

对付演习，我们将定义一个函数，该函数吸收模型、数据、优化器和丢失函数，并实行演习过程。

丢失函数：利用交叉熵丢失 (nn.CrossEntropyLoss)，适用于分类问题。
优化器：利用 Adam 优化器 (torch.optim.Adam)，它结合了 AdaGrad 和 RMSProp 优化器的优点。
演习循环：在每个 epoch 中，模型会遍历数据集中的所有批次。
对付每个批次，模型通过前向传播天生输出，打算丢失，然后通过反向传播更新权重。

import numpy as npdef train(model, data, epochs=10, batch_size=10, seq_length=50, lr=0.001): model.train() criterion = nn.CrossEntropyLoss() optimizer = torch.optim.Adam(model.parameters(), lr=lr) # 打算批次总数 total_batches = len(data) // (batch_size seq_length) # 检讨是否有足够的数据来进行至少一个批次的演习 if total_batches == 0: # print("数据量不敷，无法进行演习。
请增加数据量或减少批次大小。
") # hard code total_batches for demo total_batches = 5 for epoch in range(epochs): hidden = model.init_hidden(batch_size) total_loss = 0 # 初始化总丢失 for x, y in get_batches(data, batch_size, seq_length): inputs, targets = torch.from_numpy(x), torch.from_numpy(y) hidden = tuple([each.data for each in hidden]) model.zero_grad() output, hidden = model(inputs, hidden) loss = criterion(output, targets.view(batch_size seq_length).long()) loss.backward() optimizer.step() total_loss += loss.item() average_loss = total_loss / total_batches print(f'Epoch: {epoch + 1}/{epochs}... Loss: {average_loss}')# Helper function to create batchesdef get_batches(arr, batch_size, seq_length): arr = np.array(arr) # 将列表转换为 NumPy 数组 total_batch_size = batch_size seq_length n_batches = len(arr) // total_batch_size arr = arr[:n_batches total_batch_size] arr = arr.reshape((batch_size, -1)) for n in range(0, arr.shape[1], seq_length): x = arr[:, n:n + seq_length] y = np.zeros_like(x) try: y[:, :-1], y[:, -1] = x[:, 1:], arr[:, n + seq_length] except IndexError: y[:, :-1], y[:, -1] = x[:, 1:], arr[:, 0] yield x, y 第五步：运行演习

现在，我们可以初始化我们的模型并开始演习。

初始化模型：创建 CharRNN 实例，指定隐蔽层的大小和层数。
实行演习函数：调用 train 函数，传入模型、编码后的数据、演习轮数、批次大小、序列长度和学习率。

n_hidden=512n_layers=2model = CharRNN(chars, n_hidden, n_layers)train(model, encoded, epochs=25, batch_size=128, seq_length=100, lr=0.001)torch.save(model.state_dict(), 'char_rnn_model.pth')第六步：利用模型示例

加载演习过的模型

假设我们已经按照前面的步骤演习了模型，并且保存了模型的状态。
首先，我们须要加载这个演习过的模型。
这里，我们将利用 PyTorch 的保存和加载功能。

# 加载模型model = CharRNN(chars, n_hidden, n_layers)model.load_state_dict(torch.load('char_rnn_model.pth'))model.eval() # 将模型设置为评估模式

定义文本天生函数

接下来，我们须要定义一个函数来天生文本。
这个函数将以一定数量的字符开始，并让模型连续天生文本。

import torch.nn.functional as Fdef predict(model, char, h=None, top_k=None): if char not in char2int: print(f"字符 '{char}' 不在演习集的字符集中。
") return ' ', h # 返回空格或其他默认字符 # 将 char 转换为模型可接管的格式 x = np.zeros((1, len(chars)), dtype=np.float32) x[0, char2int[char]] = 1 x = torch.from_numpy(x) # 为 x 增加一个“批次大小”的维度，转换为浮点型并增加批次大小维度 x = x.float().unsqueeze(0) # 现在 x 是浮点型的 3D 张量 if h is not None: h = tuple([each.data for each in h]) out, h = model(x, h) p = F.softmax(out, dim=1).data p = p.cpu() # move to cpu # get top characters if top_k is not None: p, top_ch = p.topk(top_k) top_ch = top_ch.numpy().squeeze() p = p.numpy().squeeze() char = np.random.choice(top_ch, p=p / p.sum()) else: top_ch = np.array(range(len(model.chars))) p = p.numpy().squeeze() char = np.random.choice(top_ch, p=p) return int2char[char], hdef sample(model, size, prime='The', top_k=None): model.eval() # eval mode chars = [ch for ch in prime] h = model.init_hidden(1) for ch in prime: char, h = predict(model, ch, h, top_k=top_k) chars.append(char) for ii in range(size): char, h = predict(model, chars[-1], h, top_k=top_k) chars.append(char) return ''.join(chars)

天生文本

现在我们可以利用我们的模型来天生文本了。
可以通过改变 size 参数来掌握天生文本的长度，prime 参数用于指定天生文本的开始字符。

print(sample(model, size=100, prime='hello', top_k=5))

在这个示例中，sample 函数首先设置模型为评估模式，然后利用一个起始字符串（在这个例子中是 "Hello"）开始天生文本。
predict 函数每次天生一个字符，并且可以利用 top_k 参数来掌握字符选择的多样性。

总结

前五个步骤演示了如何利用 PyTorch 演习天生式 AI 模型的基本步骤。
关键步骤包括准备数据、定义模型架构和运行演习循环。
这只是一个大略的示范，真实场景须要更繁芜的数据预处理、模型调优和打算资源。
演习天生模型的过程是迭代的，常日涉及微调和实验，以达到期望的性能。

第六步中的代码仅仅展示了文本天生的基本观点。
实际运用中，可能须要进一步调整这个过程，以产生更连贯、更故意义的文本。
这包括更繁芜的状态管理和可能的后处理步骤，以改进天生文本的质量和可读性。