从零构建字符级RNN：用PyTorch实现莎士比亚风格文本生成

aiguangyuan2026-01-26 11:43

1. 引言：文本生成的魅力与挑战

在人工智能领域，文本生成一直是最具挑战性和最引人入胜的任务之一。从莎士比亚的十四行诗到现代的新闻写作，让机器学会"创作"文字不仅是技术的突破，更是对人类语言本质的探索。文本生成技术的应用广泛而深远：智能聊天机器人、自动摘要系统、代码生成助手，甚至是创意写作工具，都在改变我们与计算机交互的方式。

传统基于规则的方法难以应对自然语言的复杂性，而深度学习的出现为文本生成带来了革命性的变化。特别是循环神经网络（RNN），因其处理序列数据的天然优势，在文本生成任务中表现出色。本文将带您从零开始，使用PyTorch构建一个字符级RNN模型，并训练它生成莎士比亚风格的文本。

2. 环境配置与数据准备

2.1. 核心库介绍

构建文本生成系统需要多个Python库的支持：

python 复制代码 
import torch
import torch.nn as nn
import torch.optim as optim
import numpy as np
import random
import sys

# 设置编码，解决中文输出问题
if sys.stdout.encoding != 'utf-8':
    sys.stdout.reconfigure(encoding='utf-8')
if sys.stderr.encoding != 'utf-8':
    sys.stderr.reconfigure(encoding='utf-8')

  • PyTorch：灵活的深度学习框架，支持动态计算图

  • torch.nn：神经网络模块，提供各种层和损失函数

  • torch.optim：优化器模块，包含Adam、SGD等优化算法

  • NumPy：数值计算基础库

  • random：随机数生成，用于数据采样

2.2. 数据准备与预处理

字符级文本生成将文本视为字符序列，每个字符作为一个独立的单元：

python 复制代码 
# 1. 数据准备
corpus = """
To be, or not to be, that is the question:
Whether 'tis nobler in the mind to suffer
The slings and arrows of outrageous fortune,
Or to take arms against a sea of troubles
And by opposing end them.
""".lower()

# 创建字符到索引的映射
chars = sorted(list(set(corpus)))
char_to_index = {char: i for i, char in enumerate(chars)}
index_to_char = {i: char for i, char in enumerate(chars)}
vocab_size = len(chars)
  1. 字符级处理的优势

  • 简单直接：不需要分词，直接处理原始字符

  • 处理任意文本：能处理任何语言的文本，包括代码和特殊符号

  • 捕捉细粒度模式：能学习字符级别的规律，如单词拼写

  1. 文本预处理步骤

  • 统一大小写：将文本转换为小写，减少词汇表大小

  • 构建词汇表：提取所有唯一字符，建立字符与索引的映射

  • 序列编码：将文本转换为数字序列，便于模型处理

2.3. 创建训练序列

RNN需要序列化的输入数据，我们将文本分割为固定长度的序列：

python 复制代码 
seq_length = 40  # 序列长度
input_seqs = []  # 输入序列
target_seqs = []  # 目标序列

for i in range(len(corpus) - seq_length):
    # 输入序列：从位置i开始的seq_length个字符
    input_seqs.append([char_to_index[char] for char in corpus[i:i+seq_length]])
    # 目标序列：从位置i+1开始的seq_length个字符
    target_seqs.append([char_to_index[char] for char in corpus[i+1:i+seq_length+1]])

通过滑动窗口方法，我们可以从一个较长的文本中创建多个训练样本，最大化数据利用率。目标序列是输入序列向右移动一个字符，这样模型就能学习到"给定前文，预测下一个字符"的任务。

3. 构建字符级RNN模型

3.1. 模型架构设计

字符级RNN模型包含三个主要组件：嵌入层、RNN层和全连接输出层：

python 复制代码 
# 2. 定义字符级RNN模型
class CharRNN(nn.Module):
    def __init__(self, vocab_size, embedding_dim, hidden_size):
        super(CharRNN, self).__init__()
        self.hidden_size = hidden_size
        
        # 嵌入层：将字符索引转换为密集向量
        self.embedding = nn.Embedding(vocab_size, embedding_dim)
        
        # RNN层：处理序列数据
        self.rnn = nn.RNN(embedding_dim, hidden_size, batch_first=True)
        
        # 全连接层：将RNN输出转换为字符概率分布
        self.fc = nn.Linear(hidden_size, vocab_size)
    
    def forward(self, x, hidden):
        # 字符索引 -> 嵌入向量
        x = self.embedding(x)
        
        # RNN前向传播
        output, hidden = self.rnn(x, hidden)
        
        # 全连接层输出
        output = self.fc(output)
        
        return output, hidden
    
    def init_hidden(self, batch_size=1):
        # 初始化隐藏状态为零向量
        return torch.zeros(1, batch_size, self.hidden_size)

3.1.1. 嵌入层的作用

嵌入层将离散的字符索引转换为连续的密集向量表示。这种表示能够：

  • 捕捉语义关系：相似字符有相似的向量表示

  • 降维效果：将高维的one-hot向量压缩为低维密集向量

  • 提供可学习的特征：在训练过程中优化字符表示

3.1.2. RNN层的工作原理

RNN通过循环连接保持对之前信息的记忆：

  • 隐藏状态：在每个时间步更新，携带序列的历史信息

  • 时间展开：可以展开为多个时间步的链式结构

  • 参数共享：所有时间步共享相同的权重参数

3.2. 模型参数选择

选择合适的模型参数对性能至关重要：

python 复制代码 
# 定义模型参数
embedding_dim = 16    # 嵌入层维度
hidden_size = 64      # 隐藏层大小
learning_rate = 0.005 # 学习率
epochs = 500          # 训练轮数

3.2.1. 参数调优指南

  • 嵌入维度：通常16-256之间，维度越高表示能力越强，但也更容易过拟合

  • 隐藏层大小：决定模型记忆能力，太小会欠拟合，太大会过拟合

  • 序列长度：影响模型能看到的上下文长度，通常20-100之间

  • 学习率：控制参数更新速度，太大可能不稳定，太小收敛慢

4. 模型训练策略

4.1. 训练循环设计

训练循环是模型学习的核心，包含前向传播、损失计算和反向传播：

python 复制代码 
# 3. 模型训练
model = CharRNN(vocab_size, embedding_dim, hidden_size)
criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(model.parameters(), lr=learning_rate)

print("开始训练升级版RNN模型...")
for epoch in range(epochs):
    # 随机选择一个训练序列
    seq_idx = random.randint(0, len(input_seqs) - 1)
    
    # 准备输入和目标张量
    input_tensor = torch.tensor(input_seqs[seq_idx]).unsqueeze(0)
    target_tensor = torch.tensor(target_seqs[seq_idx])
    
    # 初始化隐藏状态
    hidden = model.init_hidden()
    
    # 梯度清零
    optimizer.zero_grad()
    
    # 前向传播
    outputs, hidden = model(input_tensor, hidden)
    
    # 计算损失
    loss = criterion(outputs.squeeze(0), target_tensor)
    
    # 反向传播和参数更新
    loss.backward()
    optimizer.step()
    
    # 定期输出训练进度
    if (epoch + 1) % 50 == 0:
        print(f"Epoch [{epoch+1}/{epochs}], Loss: {loss.item():.4f}")

print("训练完成！")

4.1.1. 损失函数选择

交叉熵损失特别适合分类任务，它衡量模型预测的概率分布与真实分布之间的差异：

  • 公式：L = -Σ y_i * log(ŷ_i)

  • 优点：对错误预测给予更大惩罚

  • 适合场景：多分类问题，如字符预测

4.1.2. 优化器配置

Adam优化器结合了动量和自适应学习率的优点：

  • 动量项：加速梯度下降过程

  • 自适应学习率：为每个参数调整学习率

  • 偏差校正：解决初始偏差问题

4.2. 训练技巧与优化

4.2.1. 批次训练

当前实现使用单个序列训练，可以改进为批次训练：

python 复制代码 
# 批次训练示例
batch_size = 32
for epoch in range(epochs):
    # 随机选择批次序列
    indices = random.sample(range(len(input_seqs)), batch_size)
    
    # 准备批次数据
    batch_input = torch.stack([torch.tensor(input_seqs[i]) for i in indices])
    batch_target = torch.stack([torch.tensor(target_seqs[i]) for i in indices])
    
    # 训练步骤...

4.2.2. 梯度裁剪

防止梯度爆炸，提高训练稳定性：

python 复制代码 
# 梯度裁剪
torch.nn.utils.clip_grad_norm_(model.parameters(), max_norm=1.0)

4.2.3. 学习率调度

动态调整学习率，提高收敛速度：

python 复制代码 
# 学习率调度
scheduler = torch.optim.lr_scheduler.StepLR(optimizer, step_size=100, gamma=0.1)

5. 文本生成与温度采样

5.1. 基础生成方法

训练完成后，模型可以根据给定的起始字符生成文本：

python 复制代码 
# 4.生成文本（温度采样）
def generate_text(model, start_char, length, temperature=0.8):
    """
    生成文本的函数
    temperature: 控制随机性的参数。
      - 值越高(>1.0)，生成的文本越随机、越有"创意"；
      - 值越低(<1.0)，生成的文本越保守、越接近模型学到的模式。
      - 值为1.0时，按原始概率分布采样。
    """
    model.eval()  # 切换到评估模式
    with torch.no_grad():
        result = start_char
        input_char = torch.tensor([char_to_index[start_char]]).unsqueeze(0)
        hidden = model.init_hidden()
        
        for _ in range(length):
            output, hidden = model(input_char, hidden)
            output_dist = output.squeeze(0).div(temperature).exp()
            top_i = torch.multinomial(output_dist, 1)[0]
            predicted_char = index_to_char[top_i.item()]
            result += predicted_char
            input_char = torch.tensor([top_i.item()]).unsqueeze(0)
    
    return result

5.2. 温度采样原理

温度采样是控制生成文本多样性的关键技术：

5.2.1. 温度参数的作用

  • 低温度（<1.0）：放大高概率字符的优势，生成更确定、保守的文本

  • 中等温度（≈1.0）：保持原始概率分布，平衡确定性和多样性

  • 高温度（>1.0）：平滑概率分布，增加多样性，可能生成更有创意的文本

5.2.2. 温度计算公式

softmax_with_temperature(x) = exp(x / T) / Σ exp(x_j / T)

其中T是温度参数，控制概率分布的平滑程度。

5.3. 生成结果分析

尝试不同温度参数，观察生成文本的变化：

python 复制代码 
# 尝试不同的温度来观察生成效果
print("\n--- 生成文本 (温度: 0.5 - 比较保守) ---")
print(generate_text(model, 't', 200, temperature=0.5))

print("\n--- 生成文本 (温度: 1.0 - 更有创意) ---")
print(generate_text(model, 't', 200, temperature=1.0))

print("\n--- 生成文本 (温度: 1.5 - 可能开始胡言乱语) ---")
print(generate_text(model, 't', 200, temperature=1.5))

不同温度下的文本特点：

  • 低温度（0.5）：文本连贯但重复性较高，可能陷入循环

  • 中温度（1.0）：平衡连贯性和多样性，最接近人类写作

  • 高温度（1.5）：创意性强但可能不合逻辑，适合需要"灵感"的场景

6. 模型改进与扩展

6.1. 高级RNN架构

6.1.1. LSTM（长短时记忆网络）

解决传统RNN的梯度消失问题，适合长序列：

python 复制代码 
class CharLSTM(nn.Module):
    def __init__(self, vocab_size, embedding_dim, hidden_size):
        super(CharLSTM, self).__init__()
        self.embedding = nn.Embedding(vocab_size, embedding_dim)
        self.lstm = nn.LSTM(embedding_dim, hidden_size, batch_first=True)
        self.fc = nn.Linear(hidden_size, vocab_size)
    
    def forward(self, x, hidden):
        x = self.embedding(x)
        output, hidden = self.lstm(x, hidden)
        output = self.fc(output)
        return output, hidden

6.1.2. GRU（门控循环单元）

简化版LSTM，计算效率更高：

python 复制代码 
class CharGRU(nn.Module):
    def __init__(self, vocab_size, embedding_dim, hidden_size):
        super(CharGRU, self).__init__()
        self.embedding = nn.Embedding(vocab_size, embedding_dim)
        self.gru = nn.GRU(embedding_dim, hidden_size, batch_first=True)
        self.fc = nn.Linear(hidden_size, vocab_size)

6.2. 多层RNN

增加模型深度，提高表示能力：

python 复制代码 
# 多层RNN示例
self.rnn = nn.RNN(embedding_dim, hidden_size, 
                  num_layers=3,  # 3层RNN
                  batch_first=True,
                  dropout=0.2)   # 层间dropout防止过拟合

6.3. 双向RNN

同时考虑前后文信息，提高上下文理解：

python 复制代码 
# 双向RNN示例
self.rnn = nn.RNN(embedding_dim, hidden_size,
                  batch_first=True,
                  bidirectional=True)  # 双向RNN

7. 实际应用场景

7.1. 创意写作助手

基于训练的模型构建创意写作工具：

  • 诗歌生成：学习特定诗人的风格

  • 故事续写：给定开头，生成后续情节

  • 歌词创作：模仿特定音乐人的作词风格

7.2. 代码自动补全

字符级RNN特别适合代码生成：

  • 代码补全：根据已有代码预测下一段

  • 代码纠错：识别和修正常见编码错误

  • API建议：根据上下文推荐合适的函数调用

7.3. 数据增强

为NLP任务生成训练数据：

  • 文本扩充：为分类任务生成更多样本

  • 风格转换：将文本转换为特定风格

  • 语言模拟：模拟特定领域或作者的语言风格

8. 性能优化建议

8.1. 计算优化

  • GPU加速：利用PyTorch的GPU支持

  • 混合精度训练：使用float16减少内存占用

  • 梯度累积：模拟大批次训练，减少内存需求

8.2. 质量提升

  • 束搜索：生成多个候选序列，选择最优

  • 重复惩罚：避免生成重复的短语

  • 长度惩罚：控制生成文本的长度分布

8.3. 部署考虑

  • 模型量化：减小模型大小，提高推理速度

  • ONNX导出：跨平台部署支持

  • 缓存优化：缓存频繁使用的计算结果

9. 完整代码示例

以下是完整的字符级RNN文本生成代码：

python 复制代码 
import torch
import torch.nn as nn
import torch.optim as optim
import numpy as np
import random
import sys

# 设置标准输出编码为UTF-8，解决中文乱码问题
if sys.stdout.encoding != 'utf-8':
    sys.stdout.reconfigure(encoding='utf-8')
if sys.stderr.encoding != 'utf-8':
    sys.stderr.reconfigure(encoding='utf-8')

# 1. 数据准备
corpus = """
To be, or not to be, that is the question:
Whether 'tis nobler in the mind to suffer
The slings and arrows of outrageous fortune,
Or to take arms against a sea of troubles
And by opposing end them.
""".lower()

chars = sorted(list(set(corpus))) # 去重并排序所有字符
char_to_index = {char:i for i,char in enumerate(chars)} # 创建字符到索引的映射
index_to_char = {i:char for i,char in enumerate(chars)} # 创建索引到字符的映射
vocab_size = len(chars) # 词汇表大小

seq_length = 40 # 序列长度
input_seqs = [] # 输入序列
target_seqs = [] # 目标序列

for i in range(len(corpus) - seq_length): # 遍历所有可能的序列
  input_seqs.append([char_to_index[char] for char in corpus[i:i+seq_length]]) # 添加输入序列
  target_seqs.append([char_to_index[char] for char in corpus[i+1:i+seq_length+1]]) # 添加目标序列

# 2. 定义字符级RNN模型
class CharRNN(nn.Module): # 字符级RNN模型

  def __init__(self,vocab_size,embedding_dim,hidden_size): # 初始化字符级RNN模型
    super(CharRNN,self).__init__() # 调用父类初始化方法
    self.hidden_size = hidden_size # 隐藏层大小
    self.embedding = nn.Embedding(vocab_size,embedding_dim) # 嵌入层
    self.rnn = nn.RNN(embedding_dim,hidden_size,batch_first=True) # RNN层
    self.fc = nn.Linear(hidden_size,vocab_size) # 全连接层

  def forward(self,x,hidden): # 前向传播
    x = self.embedding(x) # 嵌入层
    output,hidden = self.rnn(x,hidden) # RNN层
    output = self.fc(output) # 全连接层
    return output,hidden # 返回输出和隐藏状态

  def init_hidden(self,batch_size=1): # 初始化隐藏状态
    return torch.zeros(1,batch_size,self.hidden_size) # 返回全零隐藏状态


# 3. 模型训练
# 定义模型参数
embedding_dim = 16 # 嵌入层维度
hidden_size = 64 # 隐藏层大小
learning_rate = 0.005 # 学习率
epochs = 500 # 训练轮数

model = CharRNN(vocab_size,embedding_dim,hidden_size) # 创建字符级RNN模型
criterion = nn.CrossEntropyLoss() # 定义损失函数（交叉熵损失）
optimizer = optim.Adam(model.parameters(),lr=learning_rate) # 定义优化器（Adam优化器）

print("开始训练升级版RNN模型...")
for epoch in range(epochs):
  seq_idx = random.randint(0,len(input_seqs)-1)
  input_tensor = torch.tensor(input_seqs[seq_idx]).unsqueeze(0) # 添加批次维度
  target_tensor = torch.tensor(target_seqs[seq_idx]) # 添加批次维度
  hidden = model.init_hidden() # 初始化隐藏状态
  optimizer.zero_grad() # 梯度清零

  outputs,hidden = model(input_tensor,hidden) # 前向传播
  loss = criterion(outputs.squeeze(0),target_tensor) # 计算损失
  loss.backward() # 反向传播
  optimizer.step() # 更新参数

  if (epoch+1) % 50 == 0:
    print(f"Epoch [{epoch+1}/{epochs}], Loss: {loss.item():.4f}")

print("训练完成！")

# 4.生成文本（温度采样）
def generate_text(model,start_char,length,temperature = 0.8):
    """
    生成文本的函数
    temperature: 控制随机性的参数。
      - 值越高(>1.0)，生成的文本越随机、越有"创意"；
      - 值越低(<1.0)，生成的文本越保守、越接近模型学到的模式。
      - 值为1.0时，按原始概率分布采样。
    """

    model.eval() # 切换到评估模式
    with torch.no_grad(): #
      result = start_char
      input_char = torch.tensor([char_to_index[start_char]]).unsqueeze(0) # 输入字符的索引
      hidden = model.init_hidden() # 初始化隐藏状态
      for _ in range(length): # 生成指定长度的文本
        output,hidden = model(input_char,hidden) # 前向传播
        output_dist = output.squeeze(0).div(temperature).exp() # 应用温度缩放并转换为概率分布
        top_i = torch.multinomial(output_dist,1)[0] # 按概率采样
        predicted_char = index_to_char[top_i.item()] # 映射为字符
        result += predicted_char # 添加到结果字符串
        # 将当前预测的字符作为下一个时间步的输入
        input_char = torch.tensor([top_i.item()]).unsqueeze(0) # 更新输入字符为采样到的字符

    return result

# 尝试不同的温度来观察生成效果
print("\n--- 生成文本 (温度: 0.5 - 比较保守) ---")
print(generate_text(model, 't', 200, temperature=0.5))

print("\n--- 生成文本 (温度: 1.0 - 更有创意) ---")
print(generate_text(model, 't', 200, temperature=1.0))

print("\n--- 生成文本 (温度: 1.5 - 可能开始胡言乱语) ---")
print(generate_text(model, 't', 200, temperature=1.5))

10. 总结与展望

通过本文的完整实践，我们从零开始构建了一个字符级RNN文本生成系统。这个系统虽然简单，但包含了从数据处理到模型训练再到文本生成的完整流程，为更复杂的文本生成任务奠定了基础。

未来发展方向包括：

  • Transformer架构：使用自注意力机制处理长序列

  • 预训练语言模型：如GPT系列模型，在大量数据上预训练

  • 条件生成：控制生成文本的主题、风格和情感

  • 多模态生成：结合图像、音频等其他模态信息

文本生成技术的发展正在不断推动人工智能的边界，从简单的字符预测到复杂的创意写作，机器正在学习如何以更自然、更有创意的方式与人类交流。掌握这些基础技术，将为深入探索自然语言处理的更高级应用打下坚实基础。

相关推荐
Yiyaoshujuku2 小时前
疾病的发病率、发病人数、患病率、患病人数、死亡率、死亡人数查询网站及数据库
数据库·人工智能·算法
larance2 小时前
机器学习分类和设计原则
人工智能·机器学习·分类
boring_1112 小时前
AI时代本质的思考
网络·人工智能·智能路由器
红尘炼丹客2 小时前
论文《LLM-in-Sandbox Elicits General Agentic Intelligence》解析
人工智能·深度学习·大模型·llm-in-sandbox
梦幻精灵_cq2 小时前
《双征color》诗解——梦幻精灵_cq对终端渲染的数据结构设计模型式拓展
数据结构·python
青主创享阁2 小时前
玄晶引擎：基于多模态大模型的全流程AI自动化架构设计与落地实践
运维·人工智能·自动化
世优科技虚拟人2 小时前
从吉祥物“复活”到AI实训：世优科技数字人赋能智慧校园升级
人工智能
jiang_changsheng2 小时前
comfyui节点插件笔记总结新增加
人工智能·算法·计算机视觉·comfyui
BEOL贝尔科技2 小时前
通过采集器监测环境的温湿度如果这个采集器连上网络接入云平台会发生什么呢?
网络·人工智能·数据分析
热门推荐
01GitHub 镜像站点02OpenCode 入门教程：介绍 · 安装 · 配置第三方 API (如 Claude)03Claude Code Skills 实用使用手册04UV安装并设置国内源05Open Code教程（四）| 高级配置与集成06Linux下V2Ray安装配置指南07在VSCode配置Java开发环境的保姆级教程（适配各类AI编程IDE）08安娜的档案(Anna’s Archive) 镜像网站/国内最新可访问入口（持续更新）09MC.JS 网页版《我的世界》 免安装中文版10BongoCat - 跨平台键盘猫动画工具