目录

循环神经网络

示例

Python 案例

循环神经网络

• 概述：循环神经网络是一种专门用于处理序列数据的神经网络，如时间序列数据、文本数据等。与传统的神经网络不同，RNN 具有 “记忆” 能力，能够利用过去的信息来处理当前的输入，从而更好地捕捉序列中的长期依赖关系。
• 工作原理
  • 神经元结构：RNN 的基本单元是神经元，每个神经元除了接收当前的输入数据外，还接收来自上一个时间步的自身输出作为额外输入。这使得神经元能够将过去的信息整合到当前的计算中。
  • 时间序列处理：在处理序列数据时，RNN 按时间步逐个处理输入。在每个时间步，它接收输入和上一个时间步的隐藏状态​，通过一个非线性函数计算当前时间步的隐藏状态，即。隐藏状态可以看作是 RNN 对到当前时间步为止的输入序列的 “记忆” 或 “总结”。
  • 输出计算：根据当前的隐藏状态，RNN 可以生成输出​。输出可以是预测的结果，也可以是对输入序列的某种表示。输出的计算方式通常也是一个非线性函数，例如，其中是输出函数。
• 反向传播算法：在训练 RNN 时，常用的算法是时间反向传播算法（Backpropagation Through Time，BPTT）。它的基本思想是将误差从输出层反向传播到每个时间步的神经元，计算每个时间步的参数梯度，然后根据梯度更新参数。由于 RNN 在时间上的展开结构，BPTT 需要在时间维度上进行反向传播，以考虑序列中各个时间步之间的依赖关系。

示例

假设我们要构建一个 RNN 来预测股票价格的走势。输入数据是一系列的股票价格时间序列，每个时间步的输入可以是某一时刻的股票价格、成交量等特征。RNN 的隐藏状态会随着时间步的推进不断更新，记录下之前股票价格的变化趋势等信息。根据当前的隐藏状态，RNN 输出对下一个时间步股票价格的预测值。例如，在第一天，RNN 根据当天的股票价格等输入计算出隐藏状态，并输出对第二天股票价格的预测。在第二天，它将第一天的隐藏状态和第二天的输入结合起来，更新隐藏状态并预测第三天的股票价格，以此类推。通过不断地训练，RNN 可以学习到股票价格序列中的规律，从而进行较为准确的预测。

Python 案例

以下是使用 Python 和 PyTorch 库构建一个简单的 RNN 来对 MNIST 手写数字数据集进行分类的案例：

import torch
import torch.nn as nn
import torch.optim as optim
import torchvision
import torchvision.transforms as transforms

# 数据预处理
transform = transforms.Compose([
    transforms.ToTensor(),
    transforms.Normalize((0.5,), (0.5,))
])

# 加载MNIST数据集
trainset = torchvision.datasets.MNIST(root='./data', train=True, download=True, transform=transform)
trainloader = torch.utils.data.DataLoader(trainset, batch_size=32, shuffle=True)

testset = torchvision.datasets.MNIST(root='./data', train=False, download=True, transform=transform)
testloader = torch.utils.data.DataLoader(testset, batch_size=32, shuffle=False)

# 定义RNN模型
class RNN(nn.Module):
    def __init__(self, input_size, hidden_size, num_classes):
        super(RNN, self).__init__()
        self.hidden_size = hidden_size
        self.rnn = nn.RNN(input_size, hidden_size, batch_first=True)
        self.fc = nn.Linear(hidden_size, num_classes)

    def forward(self, x):
        batch_size = x.size(0)
        # 初始化隐藏状态
        h0 = torch.zeros(1, batch_size, self.hidden_size).to(x.device)

        # 前向传播
        out, _ = self.rnn(x, h0)

        # 取最后一个时间步的输出
        out = out[:, -1, :]

        # 全连接层
        out = self.fc(out)
        return out

# 超参数设置
input_size = 28
hidden_size = 128
num_classes = 10
learning_rate = 0.001

# 创建模型、损失函数和优化器
model = RNN(input_size, hidden_size, num_classes)
criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(model.parameters(), lr=learning_rate)

# 训练模型
num_epochs = 10
for epoch in range(num_epochs):
    for i, (images, labels) in enumerate(trainloader):
        # 调整输入形状为(batch_size, sequence_length, input_size)
        images = images.view(-1, 28, 28)

        # 梯度清零
        optimizer.zero_grad()

        # 前向传播
        outputs = model(images)
        loss = criterion(outputs, labels)

        # 反向传播和优化
        loss.backward()
        optimizer.step()

        if (i + 1) % 100 == 0:
            print(f'Epoch [{epoch + 1}/{num_epochs}], Step [{i + 1}/{len(trainloader)}], Loss: {loss.item():.4f}')

# 测试模型
model.eval()
with torch.no_grad():
    correct = 0
    total = 0
    for images, labels in testloader:
        images = images.view(-1, 28, 28)
        outputs = model(images)
        _, predicted = torch.max(outputs.data, 1)
        total += labels.size(0)
        correct += (predicted == labels).sum().item()

    print(f'Accuracy on the test set: {100 * correct / total}%')

在上述代码中：

1. 数据预处理与加载：对 MNIST 数据集进行预处理，将图像转换为张量并归一化，然后使用 DataLoader 加载训练集和测试集。
2. 模型定义：定义了一个 RNN 类，包含一个 RNN 层和一个全连接层。RNN 层用于处理序列数据，全连接层用于将隐藏状态映射到输出类别。
3. 超参数设置：设置了输入大小、隐藏层大小、类别数和学习率等超参数。
4. 模型训练：使用交叉熵损失函数和 Adam 优化器对模型进行训练，在每个批次中进行前向传播、计算损失、反向传播和更新参数的操作，并定期打印损失。
5. 模型测试：在测试集上评估模型的性能，计算预测准确率并打印输出。