循环神经网络：从基础到应用的深度解析

import torch
import torch.nn as nn
import torch.optim as optim

# 定义RNN模型
class RNNModel(nn.Module):
    def __init__(self, input_size, hidden_size, output_size):
        super(RNNModel, self).__init__()
        self.rnn = nn.RNN(input_size, hidden_size, batch_first=True)
        self.fc = nn.Linear(hidden_size, output_size)
        
    def forward(self, x):
        # x: 输入的序列数据
        out, _ = self.rnn(x)  # 获取RNN的输出
        out = out[:, -1, :]  # 只取最后一个时间步的输出
        out = self.fc(out)
        return out

# 参数设置
input_size = 10  # 输入特征的维度
hidden_size = 50  # 隐藏层的维度
output_size = 2  # 输出的类别数（例如，二分类问题）

# 创建模型
model = RNNModel(input_size, hidden_size, output_size)

# 定义损失函数和优化器
criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(model.parameters(), lr=0.001)

# 示例输入数据
inputs = torch.randn(32, 5, input_size)  # 32个样本，每个样本有5个时间步，输入特征维度为10
labels = torch.randint(0, 2, (32,))  # 随机生成标签，2类

# 训练过程
outputs = model(inputs)
loss = criterion(outputs, labels)
optimizer.zero_grad()
loss.backward()
optimizer.step()

print(f"Loss: {loss.item()}")

pip install torch torchvision torchaudio torchtext

import torch
import torch.nn as nn
import torch.optim as optim
import torchtext
from torchtext.datasets import IMDB
from torchtext.data import Field, BucketIterator

# 数据预处理
TEXT = Field(sequential=True, tokenize='spacy', include_lengths=True)
LABEL = Field(sequential=False, use_vocab=True, is_target=True)

# 下载IMDB数据集
train_data, test_data = IMDB.splits(TEXT, LABEL)

# 构建词汇表并用预训练的GloVe词向量初始化
TEXT.build_vocab(train_data, vectors='glove.6B.100d', min_freq=10)
LABEL.build_vocab(train_data)

# 创建训练和测试数据迭代器
train_iterator, test_iterator = BucketIterator.splits(
    (train_data, test_data),
    batch_size=64,
    device=torch.device('cuda' if torch.cuda.is_available() else 'cpu'),
    sort_within_batch=True,
    sort_key=lambda x: len(x.text)
)

# 定义RNN模型
class RNNModel(nn.Module):
    def __init__(self, input_dim, embedding_dim, hidden_dim, output_dim, n_layers, dropout):
        super(RNNModel, self).__init__()
        self.embedding = nn.Embedding(input_dim, embedding_dim)
        self.rnn = nn.RNN(embedding_dim, hidden_dim, num_layers=n_layers, dropout=dropout, batch_first=True)
        self.fc = nn.Linear(hidden_dim, output_dim)
        self.dropout = nn.Dropout(dropout)
    
    def forward(self, text, text_lengths):
        embedded = self.embedding(text)
        packed_embedded = nn.utils.rnn.pack_padded_sequence(embedded, text_lengths, batch_first=True, enforce_sorted=False)
        packed_output, hidden = self.rnn(packed_embedded)
        output = self.dropout(hidden[-1])
        return self.fc(output)

# 超参数设置
input_dim = len(TEXT.vocab)
embedding_dim = 100
hidden_dim = 256
output_dim = len(LABEL.vocab)
n_layers = 2
dropout = 0.5

# 初始化模型、损失函数和优化器
model = RNNModel(input_dim, embedding_dim, hidden_dim, output_dim, n_layers, dropout)
optimizer = optim.Adam(model.parameters())
criterion = nn.CrossEntropyLoss()

# 将模型和数据转移到GPU（如果可用）
device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
model = model.to(device)
criterion = criterion.to(device)

# 训练模型
def train(model, iterator, optimizer, criterion):
    model.train()
    epoch_loss = 0
    epoch_acc = 0
    
    for batch in iterator:
        text, text_lengths = batch.text
        labels = batch.label
        
        optimizer.zero_grad()
        
        # 预测
        predictions = model(text, text_lengths).squeeze(1)
        
        # 计算损失和准确率
        loss = criterion(predictions, labels)
        acc = binary_accuracy(predictions, labels)
        
        # 反向传播
        loss.backward()
        optimizer.step()
        
        epoch_loss += loss.item()
        epoch_acc += acc.item()
    
    return epoch_loss / len(iterator), epoch_acc / len(iterator)

# 计算二分类准确率
def binary_accuracy(predictions, labels):
    preds = torch.argmax(predictions, dim=1)
    correct = (preds == labels).float()
    return correct.sum() / len(correct)

# 测试模型
def evaluate(model, iterator, criterion):
    model.eval()
    epoch_loss = 0
    epoch_acc = 0
    
    with torch.no_grad():
        for batch in iterator:
            text, text_lengths = batch.text
            labels = batch.label
            
            predictions = model(text, text_lengths).squeeze(1)
            
            loss = criterion(predictions, labels)
            acc = binary_accuracy(predictions, labels)
            
            epoch_loss += loss.item()
            epoch_acc += acc.item()
    
    return epoch_loss / len(iterator), epoch_acc / len(iterator)

# 训练过程
N_EPOCHS = 5
for epoch in range(N_EPOCHS):
    train_loss, train_acc = train(model, train_iterator, optimizer, criterion)
    test_loss, test_acc = evaluate(model, test_iterator, criterion)
    
    print(f'Epoch {epoch+1}/{N_EPOCHS}')
    print(f'Train Loss: {train_loss:.3f} | Train Acc: {train_acc*100:.2f}%')
    print(f'Test Loss: {test_loss:.3f} | Test Acc: {test_acc*100:.2f}%')