人工智能：循环神经网络（RNN）与序列数据处理实战

import torch
import torch.nn as nn

# ------------------ 方式1：最原始的 RNN Cell（理解原理用） ------------------
rnn_cell = nn.RNNCell(input_size=64, hidden_size=128)

# 单步前向
h = torch.zeros(batch, 128)
for t in range(seq_len):
    xt = x[:, t, :]           # (batch, input_size)
    h = rnn_cell(xt, h)       # h 是新的隐藏状态

# ------------------ 方式2：nn.RNN（最常用，批量处理整个序列） ------------------
rnn = nn.RNN(
    input_size=64,
    hidden_size=128,
    num_layers=2,
    bidirectional=False,      # 双向要设 True
    batch_first=True,         # [batch, seq, feature] ← 现代最常用
    dropout=0.1
)

output, hn = rnn(x)           # output: (batch, seq, num_directions*hidden)
                              # hn:    (num_layers*dir, batch, hidden)

# ------------------ 方式3：LSTM（最经典长序列模型） ------------------
lstm = nn.LSTM(
    input_size=64,
    hidden_size=128,
    num_layers=2,
    bidirectional=True,
    batch_first=True
)

output, (hn, cn) = lstm(x)    # LSTM 多了一个 cell state cn

# ------------------ 方式4：GRU（性价比最高） ------------------
gru = nn.GRU(
    input_size=64,
    hidden_size=128,
    num_layers=3,
    batch_first=True,
    dropout=0.2 if num_layers>1 else 0
)

class SentimentGRU(nn.Module):
    def __init__(self, vocab_size, embed_dim, hidden_dim, num_layers=2, bidirectional=True):
        super().__init__()
        self.embedding = nn.Embedding(vocab_size, embed_dim, padding_idx=0)
        self.gru = nn.GRU(
            embed_dim, hidden_dim,
            num_layers=num_layers,
            bidirectional=bidirectional,
            batch_first=True,
            dropout=0.3 if num_layers > 1 else 0
        )
        dir_factor = 2 if bidirectional else 1
        self.fc = nn.Linear(hidden_dim * dir_factor, 2)   # 二分类

    def forward(self, x, lengths=None):
        # x: [batch, seq_len] 长整型 token ids
        embed = self.embedding(x)                    # [batch, seq, embed]

        if lengths is not None:
            # 使用 pack_padded_sequence 避免 padding 干扰梯度
            packed = nn.utils.rnn.pack_padded_sequence(
                embed, lengths.cpu(), batch_first=True, enforce_sorted=False
            )
            _, hn = self.gru(packed)
        else:
            _, hn = self.gru(embed)

        # 取最后一层最后一个隐藏状态（双向要 concat 前后向）
        if self.gru.bidirectional:
            hn = torch.cat([hn[-2], hn[-1]], dim=-1)   # [batch, 2*hidden]
        else:
            hn = hn[-1]                                    # [batch, hidden]

        logits = self.fc(hn)
        return logits

class SequenceLabelingBiLSTM(nn.Module):
    def __init__(self, vocab_size, tagset_size, embed_dim=128, hidden_dim=256):
        super().__init__()
        self.embedding = nn.Embedding(vocab_size, embed_dim)
        self.lstm = nn.LSTM(embed_dim, hidden_dim // 2,
                           num_layers=2, bidirectional=True, batch_first=True)
        self.fc = nn.Linear(hidden_dim, tagset_size)

    def forward(self, x):
        embeds = self.embedding(x)
        lstm_out, _ = self.lstm(embeds)           # [batch, seq, hidden*2]
        logits = self.fc(lstm_out)                # [batch, seq, tag_size]
        return logits