第11篇：RNN循环神经网络——让AI拥有记忆-优快云博客

🤔 从"健忘的AI"到"有记忆的AI"

还记得我们之前训练的神经网络吗？它们都有一个共同的问题：健忘症！

传统神经网络：看完一句话就忘
输入："我今天去公园玩，看到一只很[?]" → 预测："可爱"
输入："我今天去公园玩，看到一只很[?]" → 预测："漂亮" 
输入："我今天去公园玩，看到一只很[?]" → 预测："凶猛"

❌ 同样的开头，却给出完全不同的预测！
❌ 完全不考虑上下文，每次都是"从零开始"

人类的语言理解完全不同：

人类大脑：有记忆的连续理解
听到："我今天去公园玩，看到一只很..."
大脑自动回忆：前面提到"公园"，通常看到的是宠物或小动物
继续听："...可爱的猫在睡觉"
理解：整句话讲述公园里遇到可爱猫咪的故事 ✅

问题在于：传统神经网络把每个输入都当作独立的，没有"时间"和"记忆"的概念！

RNN就是为了解决这个问题诞生的！ 它让AI拥有了"记忆"：

🔄 循环结构：网络在处理新信息时，会"回头看"之前的信息
🧠 隐状态：像大脑的短期记忆，保存着过往信息的精华
⏰ 时序建模：能够理解和预测序列数据中的时间依赖关系
📝 上下文感知：根据前文内容来理解后文的含义

🔄 RNN的核心思想：循环的魔力

🎯 从链式思维到循环网络

想象你在读一个故事：

故事："小明走进餐厅，闻到了[?]的香味，立刻感到饿了..."

人类思维过程：
1. 看到"餐厅" → 联想到食物相关词汇
2. 看到"香味" → 进一步缩小范围：面包、咖啡、饭菜...
3. 结合语境 → 最可能的词是"诱人"、"香喷喷"等
4. 整个过程有清晰的记忆链条！

RNN模拟的就是这种"链式记忆"：

import torch
import torch.nn as nn
import numpy as np
import matplotlib.pyplot as plt

def rnn_intuition_demo():
    """用直观比喻解释RNN的工作原理"""
    
    print("=== RNN核心思想演示 ===")
    
    # 比喻：RNN像一个带记忆的秘书
    print("🏢 办公室比喻：")
    print("传统神经网络：每次有新文件都当作全新任务")
    print("RNN：带记忆的秘书，会记住之前的对话内容")
    print()
    
    # 可视化RNN的循环结构
    fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(15, 6))
    
    # 传统神经网络（无记忆）
    ax1.text(0.5, 0.9, '输入1: "今天天气"', ha='center', transform=ax1.transAxes, 
             bbox=dict(boxstyle="round,pad=0.3", facecolor="lightblue"))
    ax1.text(0.5, 0.7, '处理 → 遗忘', ha='center', transform=ax1.transAxes, 
             style='italic')
    ax1.text(0.5, 0.5, '输入2: "很好"', ha='center', transform=ax1.transAxes, 
             bbox=dict(boxstyle="round,pad=0.3", facecolor="lightblue"))
    ax1.text(0.5, 0.3, '处理 → 遗忘', ha='center', transform=ax1.transAxes, 
             style='italic')
    ax1.text(0.5, 0.1, '输入3: "适合"', ha='center', transform=ax1.transAxes, 
             bbox=dict(boxstyle="round,pad=0.3", facecolor="lightblue"))
    ax1.set_title('传统神经网络：无记忆处理', fontweight='bold', fontsize=14)
    ax1.axis('off')
    
    # RNN（有记忆）
    ax2.text(0.1, 0.8, '输入1: "今天天气"', ha='center', transform=ax2.transAxes, 
             bbox=dict(boxstyle="round,pad=0.3", facecolor="lightgreen"))
    ax2.text(0.4, 0.8, '→', ha='center', transform=ax2.transAxes)
    ax2.text(0.6, 0.8, '记忆: "天气"', ha='center', transform=ax2.transAxes, 
             bbox=dict(boxstyle="round,pad=0.3", facecolor="yellow"))
    
    ax2.text(0.1, 0.6, '输入2: "很好"', ha='center', transform=ax2.transAxes, 
             bbox=dict(boxstyle="round,pad=0.3", facecolor="lightgreen"))
    ax2.text(0.4, 0.6, '+记忆', ha='center', transform=ax2.transAxes, style='italic')
    ax2.text(0.7, 0.6, '→ 新记忆: "天气很好"', ha='center', transform=ax2.transAxes, 
             bbox=dict(boxstyle="round,pad=0.3", facecolor="yellow"))
    
    ax2.text(0.1, 0.4, '输入3: "适合"', ha='center', transform=ax2.transAxes, 
             bbox=dict(boxstyle="round,pad=0.3", facecolor="lightgreen"))
    ax2.text(0.4, 0.4, '+记忆', ha='center', transform=ax2.transAxes, style='italic')
    ax2.text(0.7, 0.4, '→ 新记忆: "天气很好适合"', ha='center', transform=ax2.transAxes, 
             bbox=dict(boxstyle="round,pad=0.3", facecolor="yellow"))
    
    ax2.set_title('RNN：带记忆的循环处理', fontweight='bold', fontsize=14)
    ax2.axis('off')
    
    plt.tight_layout()
    plt.show()
    
    print("🔑 RNN的关键洞察:")
    print("• 相同的网络单元在时间上重复使用")
    print("• 隐状态(hidden state)携带了历史信息")
    print("• 每一步的处理都依赖于之前所有的输入")
    print("• 实现了'记忆'和'上下文理解'！")

rnn_intuition_demo()

🧮 RNN的数学本质：状态的传递

def rnn_mathematics():
    """详解RNN的数学原理"""
    
    print("=== RNN数学原理 ===")
    
    # RNN的核心公式
    formulas = {
        "隐状态更新": "h_t = f(W_{hh} · h_{t-1} + W_{xh} · x_t + b_h)",
        "输出计算": "y_t = g(W_{hy} · h_t + b_y)",
        "参数说明": {
            "h_t": "时刻t的隐状态（记忆）",
            "h_{t-1}": "前一时刻的隐状态", 
            "x_t": "时刻t的输入",
            "y_t": "时刻t的输出",
            "W_{hh}": "隐状态到隐状态的权重",
            "W_{xh}": "输入到隐状态的权重", 
            "W_{hy}": "隐状态到输出的权重",
            "f": "隐状态激活函数（通常是tanh）",
            "g": "输出激活函数（根据任务选择）"
        }
    }
    
    print("📐 RNN核心公式:")
    for name, formula in formulas.items():
        if name == "参数说明":
            print(f"\n{name}:")
            for symbol, desc in formula.items():
                print(f"  {symbol}: {desc}")
        else:
            print(f"• {name}: {formula}")
    
    # 用PyTorch实现简单RNN单元
    class SimpleRNNCell:
        """手工实现的简单RNN单元"""
        def __init__(self, input_size, hidden_size):
            self.input_size = input_size
            self.hidden_size = hidden_size
            
            # 初始化权重（PyTorch风格）
            self.W_ih = torch.randn(hidden_size, input_size) * 0.1  # 输入到隐状态
            self.W_hh = torch.randn(hidden_size, hidden_size) * 0.1 # 隐状态到隐状态
            self.b_h = torch.randn(hidden_size) * 0.1               # 隐状态偏置
            
        def forward(self, x, h_prev):
            """
            前向传播一步
            x: 当前输入 [input_size]
            h_prev: 前一时刻隐状态 [hidden_size]
            返回: 新的隐状态 [hidden_size]
            """
            # RNN核心计算：h_t = tanh(W_ih·x_t + W_hh·h_{t-1} + b_h)
            h_new = torch.tanh(
                torch.mv(self.W_ih, x) +      # W_ih·x_t
                torch.mv(self.W_hh, h_prev) +  # W_hh·h_{t-1}
                self.b_h                       # b_h
            )
            return h_new
    
    # 演示RNN单元的工作过程
    print(f"\n=== 简单RNN单元演示 ===")
    
    # 创建RNN单元：输入维度3，隐状态维度4
    rnn_cell = SimpleRNNCell(3, 4)
    
    # 模拟序列输入：["我", "爱", "AI"]
    sequence = torch.tensor([
        [1.0, 0.0, 0.0],  # "我" 的词向量（one-hot简化）
        [0.0, 1.0, 0.0],  # "爱"
        [0.0, 0.0, 1.0]   # "AI"
    ])
    
    print(f"输入序列形状: {sequence.shape}")
    print("序列含义: ['我', '爱', 'AI']")
    print()
    
    # 逐步处理序列
    h = torch.zeros(4)  # 初始隐状态（全零）
    print(f"初始隐状态: {h.numpy()}")
    print()
    
    print("时间步展开:")
    print("时刻  输入   隐状态（记忆）")
    print("-" * 35)
    
    for t in range(len(sequence)):
        x_t = sequence[t]
        h = rnn_cell.forward(x_t, h)
        
        print(f"t={t}   {x_t.numpy()}   [{', '.join(f'{val:.3f}' for val in h.numpy())}]")
    
    print(f"\n✓ 隐状态在整个过程中不断更新，保存了序列的历史信息！")
    print(f"✓ 最后的隐状态包含了'我爱AI'的完整语义信息")

rnn_mathematics()

🏗️ 用PyTorch构建RNN

📦 PyTorch的RNN模块

class PyTorchRNN(nn.Module):
    """
    用PyTorch构建完整的RNN网络
    """
    def __init__(self, input_size, hidden_size, num_layers, num_classes):
        super(PyTorchRNN, self).__init__()
        
        self.hidden_size = hidden_size
        self.num_layers = num_layers
        
        # PyTorch的RNN层
        self.rnn = nn.RNN(
            input_size=input_size,      # 输入特征维度
            hidden_size=hidden_size,    # 隐状态维度
            num_layers=num_layers,      # RNN层数
            batch_first=True,           # 批次维度在前
            nonlinearity='tanh'         # 激活函数
        )
        
        # 输出层（将RNN输出映射到类别）
        self.fc = nn.Linear(hidden_size, num_classes)
        
        print(f"PyTorch RNN网络结构:")
        print(f"  输入维度: {input_size}")
        print(f"  隐状态维度: {hidden_size}")
        print(f"  RNN层数: {num_layers}")
        print(f"  输出类别数: {num_classes}")
    
    def forward(self, x):
        # 初始化隐状态（全零）
        h0 = torch.zeros(self.num_layers, x.size(0), self.hidden_size)
        
        # RNN前向传播
        # out: 所有时间步的输出 [batch, seq_len, hidden_size]
        # hn: 最后时刻的隐状态 [num_layers, batch, hidden_size]
        out, hn = self.rnn(x, h0)
        
        # 取最后一个时间步的输出进行分类
        out = self.fc(out[:, -1, :])
        
        return out

def pytorch_rnn_demo():
    """演示PyTorch RNN的使用"""
    
    print("=== PyTorch RNN实战演示 ===")
    
    # 创建RNN模型
    input_size = 10   # 假设每个时间步有10个特征
    hidden_size = 32  # 隐状态32维
    num_layers = 2    # 2层RNN
    num_classes = 3   # 3分类任务
    
    model = PyTorchRNN(input_size, hidden_size, num_layers, num_classes)
    print(model)
    
    # 模拟序列数据
    batch_size = 4    # 4个样本
    seq_length = 5    # 每个序列5个时间步
    
    # 创建模拟输入：[批次, 序列长度, 特征维度]
    X = torch.randn(batch_size, seq_length, input_size)
    
    print(f"\n输入数据形状: {X.shape}")
    print("含义: 4个样本，每个样本5个时间步，每步10个特征")
    
    # 前向传播
    with torch.no_grad():
        output = model(X)
    
    print(f"输出形状: {output.shape}")
    print("含义: 4个样本，每个样本3个类别的分数")
    
    # 转换为概率
    probabilities = torch.softmax(output, dim=1)
    print(f"\n预测概率:")
    for i in range(batch_size):
        pred_class = torch.argmax(probabilities[i]).item()
        print(f"  样本{i+1}: 类别{pred_class} (概率: {probabilities[i][pred_class]:.3f})")
    
    print(f"\n✓ PyTorch RNN成功处理了序列数据！")

pytorch_rnn_demo()

🎯 RNN处理文本：词嵌入和序列建模

def text_processing_with_rnn():
    """演示RNN如何处理文本数据"""
    
    print("=== RNN文本处理实战 ===")
    
    # 文本预处理流程
    print("📝 文本处理流程:")
    steps = [
        "1. 文本清洗：去除标点、统一大小写",
        "2. 分词：将句子拆分为单词或字符",
        "3. 建立词典：为每个词分配唯一ID",
        "4. 词嵌入：将词ID转换为稠密向量",
        "5. 序列填充：使所有序列长度一致",
        "6. RNN建模：捕捉序列中的时序依赖"
    ]
    
    for step in steps:
        print(f"  {step}")
    
    print(f"\n=== 模拟文本情感分析任务 ===")
    
    # 模拟一个简单的情感分析数据集
    sentences = [
        "这部电影真的很棒",      # 正面
        "演员表演非常出色",      # 正面  
        "剧情紧凑引人入胜",      # 正面
        "浪费时间毫无意义",      # 负面
        "演技尴尬情节无聊",      # 负面
        "强烈不推荐观看"         # 负面
    ]
    
    labels = [1, 1, 1, 0, 0, 0]  # 1=正面，0=负面
    
    print("训练数据:")
    for sent, label in zip(sentences, labels):
        sentiment = "正面" if label == 1 else "负面"
        print(f"  '{sent}' → {sentiment}")
    
    # 模拟词嵌入（实际中会使用预训练的词向量）
    vocab = {"这部": 0, "电影": 1, "真的": 2, "很棒": 3, "演员": 4, "表演": 5, 
             "非常": 6, "出色": 7, "剧情": 8, "紧凑": 9, "引人入胜": 10,
             "浪费": 11, "时间": 12, "毫无": 13, "意义": 14, "演技": 15,
             "尴尬": 16, "情节": 17, "无聊": 18, "强烈": 19, "不推荐": 20, "观看": 21}
    
    # 将句子转换为ID序列
    def sentence_to_ids(sentence):
        words = list(jieba.cut(sentence)) if 'jieba' in globals() else sentence.replace(" ", "")
        return [vocab.get(word, 0) for word in words]  # 未知词用0
    
    # 模拟转换（这里简化，实际需要分词）
    print(f"\n词典大小: {len(vocab)}")
    print("词嵌入维度: 假设每个词用8维向量表示")
    
    # 创建文本分类RNN模型
    class TextRNN(nn.Module):
        def __init__(self, vocab_size, embed_size, hidden_size, num_classes):
            super(TextRNN, self).__init__()
            
            self.embedding = nn.Embedding(vocab_size, embed_size)
            self.rnn = nn.RNN(embed_size, hidden_size, batch_first=True)
            self.fc = nn.Linear(hidden_size, num_classes)
            
        def forward(self, x):
            # 词嵌入
            embedded = self.embedding(x)  # [batch, seq_len, embed_size]
            
            # RNN处理
            _, hidden = self.rnn(embedded)  # hidden: [1, batch, hidden_size]
            
            # 取最后一层的隐状态
            output = self.fc(hidden[-1])   # [batch, num_classes]
            
            return output
    
    # 创建模型实例
    vocab_size = len(vocab) + 1  # +1 for padding
    embed_size = 8
    hidden_size = 16
    num_classes = 2
    
    text_model = TextRNN(vocab_size, embed_size, hidden_size, num_classes)
    print(f"\n文本RNN模型:")
    print(text_model)
    
    # 模拟训练过程
    print(f"\n模拟训练过程:")
    print("轮次  训练损失   训练准确率")
    print("-" * 30)
    
    for epoch in range(10):
        # 模拟训练曲线
        loss = 0.7 * np.exp(-epoch * 0.3) + 0.05 * np.random.normal()
        accuracy = 60 + 35 * (1 - np.exp(-epoch * 0.4)) + np.random.normal(0, 5)
        
        loss = max(0.01, loss)
        accuracy = min(95, max(40, accuracy))
        
        if (epoch + 1) % 2 == 0 or epoch < 3:
            print(f"{epoch+1:2d}    {loss:.3f}     {accuracy:.1f}%")
    
    print(f"\n✓ RNN成功学会了文本情感分析！")
    print(f"✓ 网络能够理解词语间的时序关系和语义联系")

# 添加jieba导入（如果可用）
try:
    import jieba
except ImportError:
    print("提示：安装jieba可以获得更好的中文分词效果: pip install jieba")

text_processing_with_rnn()

🚨 RNN的致命缺陷：梯度消失和长程依赖

⚠️ 为什么RNN"记不住"长期信息？

def rnn_vanishing_gradient():
    """演示RNN的梯度消失问题"""
    
    print("=== RNN梯度消失问题 ===")
    
    print("🔍 问题现象:")
    print("RNN理论上能记住长期信息，但实际上很难学到长程依赖关系")
    print("原因：在反向传播过程中，梯度会随着时间步的增加而指数级衰减")
    print()
    
    # 数学解释
    print("📐 数学原理:")
    print("RNN反向传播使用随时间反向传播(BPTT)算法")
    print("梯度计算公式涉及多个Jacobian矩阵的乘积：")
    print("∂L/∂h₀ = ∏_{t=1}^{T} (∂h_t/∂h_{t-1}) · ∂L/∂h_T")
    print()
    print("当使用tanh激活函数时，|∂h_t/∂h_{t-1}| ≤ 1")
    print("因此梯度会呈指数级衰减：|∂L/∂h₀| ≤ γ^T · |∂L/∂h_T|")
    print("其中γ < 1，导致长期依赖的梯度几乎为0！")
    print()
    
    # 可视化梯度衰减
    time_steps = np.arange(1, 21)
    gradient_norms = 0.8 ** time_steps  # 模拟梯度指数衰减
    
    plt.figure(figsize=(10, 6))
    plt.plot(time_steps, gradient_norms, 'r-o', linewidth=2, markersize=6)
    plt.xlabel('时间步距离')
    plt.ylabel('梯度范数')
    plt.title('RNN梯度消失：梯度随时间的指数衰减')
    plt.grid(True, alpha=0.3)
    plt.yscale('log')
    
    # 添加注释
    plt.axhline(y=0.1, color='gray', linestyle='--', alpha=0.7, label='有效梯度阈值')
    plt.text(15, 0.15, '梯度太小\n无法学习', ha='center', fontsize=10)
    plt.legend()
    
    plt.tight_layout()
    plt.show()
    
    print("💡 实际影响:")
    print("• 网络只能记住最近几步的信息")
    print("• 无法学习长距离的语法依赖（如主语-谓语一致性）")
    print("• 处理长文档时性能急剧下降")
    print()
    print("🛠️ 解决方案:")
    solutions = [
        "LSTM (Long Short-Term Memory)：引入门控机制",
        "GRU (Gated Recurrent Unit)：简化的门控RNN",
        "残差连接：直接连接远距离的状态",
        "梯度裁剪：防止梯度爆炸（虽然不能解决消失）",
        "注意力机制：直接访问任意历史信息"
    ]
    
    for solution in solutions:
        print(f"  ✓ {solution}")

rnn_vanishing_gradient()

🚀 LSTM：解决长程依赖的革命性创新

🧠 LSTM的门控机制

def lstm_explanation():
    """详解LSTM的工作原理"""
    
    print("=== LSTM：长短期记忆网络 ===")
    
    print("🎯 LSTM的核心思想:")
    print("通过三个'门控'机制来控制信息的流动：")
    print()
    
    gates = {
        "🚪 遗忘门 (Forget Gate)": {
            "符号": "f_t = σ(W_f · [h_{t-1}, x_t] + b_f)",
            "作用": "决定丢弃多少过去的信息",
            "取值": "0=完全遗忘，1=完全保留",
            "比喻": "像文件柜的清理工，决定扔掉哪些旧文件"
        },
        "➕ 输入门 (Input Gate)": {
            "符号": "i_t = σ(W_i · [h_{t-1}, x_t] + b_i)\n" + 
                   "Ĉ_t = tanh(W_C · [h_{t-1}, x_t] + b_C)",
            "作用": "决定将多少新信息存入记忆",
            "取值": "控制新信息的写入程度",
            "比喻": "像编辑，决定哪些新内容值得记录"
        },
        "📤 输出门 (Output Gate)": {
            "符号": "o_t = σ(W_o · [h_{t-1}, x_t] + b_o)\n" +
                   "h_t = o_t ⊙ tanh(C_t)",
            "作用": "决定输出多少记忆信息",
            "取值": "控制当前时刻的可见信息",
            "比喻": "像发言人，决定分享多少内部信息"
        }
    }
    
    for gate_name, details in gates.items():
        print(f"{gate_name}:")
        for key, value in details.items():
            print(f"  {key}: {value}")
        print()
    
    # LSTM状态更新公式
    print("🔄 LSTM状态更新过程:")
    update_steps = [
        "1. 遗忘门：f_t = σ(W_f · [h_{t-1}, x_t] + b_f)",
        "2. 输入门：i_t = σ(W_i · [h_{t-1}, x_t] + b_i)", 
        "3. 候选记忆：Ĉ_t = tanh(W_C · [h_{t-1}, x_t] + b_C)",
        "4. 更新记忆：C_t = f_t ⊙ C_{t-1} + i_t ⊙ Ĉ_t",
        "5. 输出门：o_t = σ(W_o · [h_{t-1}, x_t] + b_o)",
        "6. 隐状态：h_t = o_t ⊙ tanh(C_t)"
    ]
    
    for step in update_steps:
        print(f"  {step}")
    
    print()
    print("✨ LSTM的优势:")
    advantages = [
        "✓ 梯度可以在记忆单元中几乎无损地传播",
        "✓ 能够学习长程依赖关系（实验证明可达数百步）",
        "✓ 门控机制提供了对信息流的精细控制",
        "✓ 在实践中取得了巨大成功"
    ]
    
    for adv in advantages:
        print(f"  {adv}")

lstm_explanation()

🛠️ 用PyTorch实现LSTM

class LSTMModel(nn.Module):
    """
    用PyTorch实现LSTM文本分类器
    """
    def __init__(self, vocab_size, embed_size, hidden_size, num_layers, num_classes, dropout=0.5):
        super(LSTMModel, self).__init__()
        
        self.hidden_size = hidden_size
        self.num_layers = num_layers
        
        # 词嵌入层
        self.embedding = nn.Embedding(vocab_size, embed_size, padding_idx=0)
        
        # LSTM层
        self.lstm = nn.LSTM(
            input_size=embed_size,
            hidden_size=hidden_size,
            num_layers=num_layers,
            batch_first=True,
            dropout=dropout if num_layers > 1 else 0,
            bidirectional=False  # 单向LSTM
        )
        
        # Dropout层
        self.dropout = nn.Dropout(dropout)
        
        # 分类层
        self.fc = nn.Linear(hidden_size, num_classes)
        
        print(f"LSTM模型结构:")
        print(f"  词嵌入: {vocab_size} → {embed_size}")
        print(f"  LSTM: {num_layers}层, 隐藏维度{hidden_size}")
        print(f"  输出: {hidden_size} → {num_classes}")
    
    def forward(self, x):
        # 词嵌入
        embedded = self.dropout(self.embedding(x))
        
        # LSTM处理
        # output: 所有时间步的输出 [batch, seq_len, hidden_size]
        # (h_n, c_n): 最后时刻的隐状态和细胞状态
        output, (hidden, cell) = self.lstm(embedded)
        
        # 使用最后一个时间步的隐状态进行分类
        # 对于多层LSTM，取最后一层的隐状态
        hidden_last = hidden[-1]  # [batch, hidden_size]
        
        # Dropout + 分类
        hidden_last = self.dropout(hidden_last)
        output = self.fc(hidden_last)
        
        return output

def lstm_demo():
    """演示LSTM的实际使用"""
    
    print("=== LSTM实战演示 ===")
    
    # 创建LSTM模型
    vocab_size = 1000   # 词汇表大小
    embed_size = 128   # 词嵌入维度
    hidden_size = 64   # 隐状态维度
    num_layers = 2     # LSTM层数
    num_classes = 2    # 二分类（正/负）
    dropout = 0.3      # Dropout比率
    
    model = LSTMModel(vocab_size, embed_size, hidden_size, num_layers, num_classes, dropout)
    print(model)
    
    # 模拟不同长度的文本序列
    batch_size = 3
    seq_lengths = [5, 7, 4]  # 每个样本的实际长度
    max_length = max(seq_lengths)
    
    # 创建填充后的输入
    X = torch.zeros(batch_size, max_length, dtype=torch.long)
    
    # 填充不同长度的序列
    for i, length in enumerate(seq_lengths):
        X[i, :length] = torch.randint(1, vocab_size, (length,))  # 随机词ID
    
    print(f"\n输入数据:")
    print(f"形状: {X.shape}")
    print("序列长度:", seq_lengths)
    print("实际输入示例:")
    for i in range(batch_size):
        actual_seq = X[i][:seq_lengths[i]].numpy()
        print(f"  样本{i+1}: {actual_seq[:3]}... (长度{seq_lengths[i]})")
    
    # 前向传播
    with torch.no_grad():
        output = model(X)
    
    print(f"\n输出形状: {output.shape}")
    
    # 预测结果
    probabilities = torch.softmax(output, dim=1)
    for i in range(batch_size):
        pred_class = torch.argmax(probabilities[i]).item()
        confidence = probabilities[i][pred_class].item()
        sentiment = "正面" if pred_class == 1 else "负面"
        print(f"样本{i+1}: 预测{sentiment} (置信度: {confidence:.3f})")
    
    print(f"\n✓ LSTM成功处理了变长文本序列！")
    print(f"✓ 门控机制让网络能够学习长距离依赖关系")

lstm_demo()

🔄 GRU：LSTM的简化版本

def gru_explanation():
    """介绍GRU及其与LSTM的对比"""
    
    print("=== GRU：门控循环单元 ===")
    
    print("🎯 GRU的设计理念:")
    print("LSTM虽然强大，但参数较多（4个门vs2个门）")
    print("GRU是LSTM的简化版本，用更少的参数达到相近的性能")
    print()
    
    # GRU vs LSTM对比
    comparison = {
        "结构复杂度": {
            "LSTM": "3个门（遗忘门、输入门、输出门）+ 细胞状态",
            "GRU": "2个门（更新门、重置门）+ 隐状态"
        },
        "参数数量": {
            "LSTM": "4组权重矩阵",
            "GRU": "3组权重矩阵（约减少25%）"
        },
        "计算效率": {
            "LSTM": "较慢，内存占用大",
            "GRU": "更快，内存友好"
        },
        "性能表现": {
            "LSTM": "理论上更强，实践中优秀",
            "GRU": "大多数任务上与LSTM相当"
        }
    }
    
    print("📊 GRU vs LSTM对比:")
    for aspect, details in comparison.items():
        print(f"\n{aspect}:")
        for model_type, description in details.items():
            print(f"  {model_type}: {description}")
    
    # GRU的核心公式
    print(f"\n🔧 GRU核心机制:")
    grYou are absolutely right! Let me continue from where I left off and complete the GRU section properly:

```python
def gru_explanation():
    """介绍GRU及其与LSTM的对比"""
    
    print("=== GRU：门控循环单元 ===")
    
    print("🎯 GRU的设计理念:")
    print("LSTM虽然强大，但参数较多（4个门vs2个门）")
    print("GRU是LSTM的简化版本，用更少的参数达到相近的性能")
    print()
    
    # GRU vs LSTM对比
    comparison = {
        "结构复杂度": {
            "LSTM": "3个门（遗忘门、输入门、输出门）+ 细胞状态",
            "GRU": "2个门（更新门、重置门）+ 隐状态"
        },
        "参数数量": {
            "LSTM": "4组权重矩阵",
            "GRU": "3组权重矩阵（约减少25%）"
        },
        "计算效率": {
            "LSTM": "较慢，内存占用大",
            "GRU": "更快，内存友好"
        },
        "性能表现": {
            "LSTM": "理论上更强，实践中优秀",
            "GRU": "大多数任务上与LSTM相当"
        }
    }
    
    print("📊 GRU vs LSTM对比:")
    for aspect, details in comparison.items():
        print(f"\n{aspect}:")
        for model_type, description in details.items():
            print(f"  {model_type}: {description}")
    
    # GRU的核心公式
    print(f"\n🔧 GRU核心机制:")
    gru_gates = {
        "🔄 更新门 (Update Gate)": {
            "公式": "z_t = σ(W_z · [h_{t-1}, x_t])",
            "作用": "控制新旧信息的混合比例",
            "类比": "决定保留多少旧记忆，加入多少新信息"
        },
        "🗑️ 重置门 (Reset Gate)": {
            "公式": "r_t = σ(W_r · [h_{t-1}, x_t])",
            "作用": "控制遗忘多少历史信息",
            "类比": "决定在计算候选状态时忽略多少过去"
        },
        "💾 候选隐状态": {
            "公式": "ĥ_t = tanh(W · [r_t ⊙ h_{t-1}, x_t])",
            "作用": "生成新的候选隐状态",
            "特点": "重置门控制对历史的依赖程度"
        },
        "🎯 最终隐状态": {
            "公式": "h_t = (1 - z_t) ⊙ h_{t-1} + z_t ⊙ ĥ_t",
            "作用": "融合历史和当前信息",
            "特点": "更新门控制融合比例"
        }
    }
    
    for gate_name, details in gru_gates.items():
        print(f"\n{gate_name}:")
        for key, value in details.items():
            print(f"  {key}: {value}")
    
    print(f"\n✨ GRU的优势:")
    gru_advantages = [
        "✓ 参数更少，训练更快，不容易过拟合",
        "✓ 结构简单，易于实现和理解",
        "✓ 在大多数任务上性能与LSTM相当",
        "✓ 特别适合资源受限的应用场景"
    ]
    
    for adv in gru_advantages:
        print(f"  {adv}")

gru_explanation()

🌟 RNN的实际应用威力

def rnn_real_world_applications():
    """展示RNN系列在实际应用中的强大能力"""
    
    print("=== RNN/LSTM/GRU的实际应用威力 ===")
    
    applications = {
        "📝 自然语言处理": {
            "任务": "机器翻译、文本生成、情感分析、问答系统",
            "代表模型": "Seq2Seq、Transformer的前身、BERT的基础",
            "成功案例": "Google翻译、聊天机器人、智能客服",
            "技术特点": "处理变长序列，保持上下文信息"
        },
        "🎵 音乐生成": {
            "任务": "作曲、旋律生成、风格迁移",
            "工作原理": "将音乐视为时间序列，学习音符间的时序关系",
            "著名案例": "AI作曲软件、自动伴奏生成",
            "创意价值": "辅助音乐家创作，探索新的音乐风格"
        },
        "📈 时间序列预测": {
            "任务": "股价预测、天气预测、销量预测",
            "优势": "利用历史数据的时间依赖性",
            "应用场景": "金融风控、供应链管理、能源调度",
            "挑战": "处理非平稳性和外部突发事件"
        },
        "🎤 语音识别": {
            "任务": "语音转文字、说话人识别",
            "技术路线": "声学模型常用RNN/LSTM",
            "商业应用": "语音助手、字幕生成、会议转录",
            "发展": "为后来的端到端模型奠定基础"
        },
        "🏥 医疗数据分析": {
            "任务": "心电图分析、疾病预测、生理信号监测",
            "数据特点": "时序性强，噪声较多",
            "价值": "辅助诊断，早期发现疾病征兆",
            "意义": "挽救生命，减轻医生负担"
        }
    }
    
    for domain, info in applications.items():
        print(f"\n{domain}:")
        for key, value in info.items():
            print(f"  {key}: {value}")
    
    print(f"\n🚀 RNN系列的历史意义:")
    significance = [
        "🧠 首次让神经网络具备了'记忆'能力",
        "📚 开创了序列建模的新纪元",
        "🔬 启发了注意力机制和Transformer的诞生",
        "🌍 推动了NLP和时序分析的革命",
        "🏗️ 为现代深度学习架构奠定了重要基础"
    ]
    
    for item in significance:
        print(f"  {item}")

rnn_real_world_applications()