importtorch
importtorch.nnasnn
importtorch.optimasoptim
importnumpyasnp
# 设置随机种子
torch.manual_seed(42)
classNumberGuessingRNN(nn.Module):
def__init__(self, input_size, hidden_size, output_size, num_layers=1):
super(NumberGuessingRNN, self).__init__()
self.hidden_size = hidden_size
self.num_layers = num_layers
# 嵌入层 - 将数字转换为向量
self.embedding = nn.Embedding(input_size, hidden_size)
# RNN层
self.rnn = nn.RNN(hidden_size, hidden_size, num_layers, batch_first=True)
# 输出层
self.fc = nn.Linear(hidden_size, output_size)
defforward(self, x, hidden=None):
# 嵌入层
embedded = self.embedding(x)
# RNN层
ifhiddenisNone:
rnn_out, hidden = self.rnn(embedded)
else:
rnn_out, hidden = self.rnn(embedded, hidden)
# 只取最后一个时间步的输出
last_output = rnn_out[:, -1, :]
# 全连接层
output = self.fc(last_output)
returnoutput, hidden
defgenerate_sequence_data(seq_length=5, num_samples=1000, max_num=20):
"""生成数字序列数据"""
sequences = []
targets = []
for_inrange(num_samples):
# 生成随机起始数字
start = np.random.randint(0, max_num-seq_length)
# 创建序列 (例如: [3,4,5,6,7])
seq = [start+iforiinrange(seq_length)]
sequences.append(seq)
# 目标是序列的下一个数字 (例如: 8)
target = start+seq_length
targets.append(target)
returnnp.array(sequences), np.array(targets)
deftrain_model():
"""训练模型"""
# 生成训练数据
sequences, targets = generate_sequence_data(seq_length=5, num_samples=10000, max_num=50)
print(sequences, len(sequences))
print(targets, len(targets))
# 转换为PyTorch张量
sequences_tensor = torch.tensor(sequences, dtype=torch.long)
targets_tensor = torch.tensor(targets, dtype=torch.long)
# 创建数据集
dataset = torch.utils.data.TensorDataset(sequences_tensor, targets_tensor)
dataloader = torch.utils.data.DataLoader(dataset, batch_size=32, shuffle=True)
# 模型参数
input_size = 51# 0-50
hidden_size = 64
output_size = 51# 0-50
num_layers = 2
# 创建模型
model = NumberGuessingRNN(input_size, hidden_size, output_size, num_layers)
# 损失函数和优化器
criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(model.parameters(), lr=0.001)
# 训练循环
forepochinrange(100):
epoch_loss = 0
forbatch_sequences, batch_targetsindataloader:
# 前向传播
outputs, _ = model(batch_sequences)
loss = criterion(outputs, batch_targets)
# 反向传播
optimizer.zero_grad() # 清空梯度
loss.backward() # 反向传播
optimizer.step() # 更新参数
print(f'Epoch [{epoch}], Loss: {loss:.4f}')returnmodel
defplay_game(model, max_num=50):
"""与训练好的模型玩猜数字游戏"""
model.eval()
print("\n=== 数字猜测游戏 ===")print("规则: 输入一个数字序列，模型会预测下一个数字")print(f"数字范围: 0-{max_num}")print("输入'quit'退出游戏\n")whileTrue:
user_input = input("请输入一个递增的数字序列 (例如: 3 4 5 6 7): ")ifuser_input.lower() == 'quit':
break
try:
# 解析输入
sequence = [int(num) fornuminuser_input.split()]
# 准备输入数据
input_tensor = torch.tensor([sequence], dtype=torch.long)
# 模型预测
withtorch.no_grad(): # 禁用梯度计算
output, _ = model(input_tensor) # 模型预测
predicted = torch.argmax(output, dim=1).item() # 获取预测结果
# 显示结果
actual_next = sequence[-1] +1
print(f"序列: {sequence}")print(f"模型预测的下一个数字: {predicted}")print(f"实际的下一个数字: {actual_next}")ifpredicted == actual_next:
print("✅ 模型猜对了!")else:
print("❌ 模型猜错了!")exceptExceptionase:
print(f"发生错误: {e}")if__name__ == "__main__":
# 训练模型
print("开始训练模型...")model = train_model()
# 玩游戏
play_game(model)
