RNN循环网络：给AI装上“记忆“（superior哥AI系列第5期）

🔄 RNN循环网络：给AI装上"记忆"（superior哥AI系列第5期）

嘿！小伙伴们，又见面啦！👋 上期我们学会了让AI"看懂"图片，今天要给AI装上一个更酷的技能——记忆力！🧠

想象一下，如果你看电影时只能看到孤立的画面，完全记不住前面的剧情，你能理解这部电影吗？😵‍💫 如果你说话时忘记上一秒说了什么，别人能听懂你在说啥吗？

这就是为什么我们需要RNN（循环神经网络）！它能让AI像人类一样拥有"记忆"，理解时间序列，掌握语言的前后文关系。今天superior哥就带你揭开RNN的神秘面纱！🎭

🤔 为什么AI需要"记忆力"？

回忆一下我们之前学过的网络

📊 传统神经网络：

就像一个"瞬间反应机器"
看到输入立马给出输出，完全不记得之前发生了什么
适合处理固定大小的数据

📸 CNN：

专门处理图像，有"空间感知能力"
但仍然是"一次性"处理，没有时间概念
看完这张照片就忘了，下张照片重新开始

🚨 传统网络遇到序列数据就"傻眼"了

生活中很多数据都是有时间顺序的：

📝 文本理解问题

句子： “我昨天去北京吃了烤鸭”
传统网络： 只能看到单个词，不知道时间关系
问题： "昨天"和"吃了"的时态关系完全丢失！

🎵 音乐识别问题

音乐： do-re-mi-fa-sol…
传统网络： 每个音符都是独立的
问题： 没有旋律的概念，无法理解音乐！

📈 股价预测问题

股价： 今天100→明天102→后天98…
传统网络： 只看当前价格
问题： 看不到趋势，预测完全没用！

所以，AI急需一种"记忆力"来处理这些序列问题！ 💪

🧠 RNN的核心思想：带着"记忆"去学习

RNN的设计哲学超级简单：让AI在处理每个新信息时，都能"回忆"起之前的经历！

🎭 生活中的记忆例子

想象你在听朋友讲故事：

朋友说：“昨天我去商场…”
👉 你的大脑记住：时间=昨天，地点=商场
朋友接着说：“买了一件衣服…”
👉 你的大脑想：昨天在商场买衣服
朋友最后说：“今天穿着很帅！”
👉 你理解了：昨天买的衣服今天穿着帅

这就是RNN的工作方式！每处理一个新词，都会结合之前的"记忆"！

🔄 RNN的工作机制

RNN的核心创新就是引入了**“循环连接”**：

传统网络：失忆症患者

输入 → 处理 → 输出 
(每次都是全新开始，完全不记得之前的事)

RNN：有记忆力的智者

输入₁ → 处理 → 输出₁ → 记忆₁
       ↓
输入₂ → 处理 ← 记忆₁ → 输出₂ → 记忆₂  
       ↓
输入₃ → 处理 ← 记忆₂ → 输出₃ → 记忆₃

🎯 RNN的三个关键步骤

在每个时间步，RNN都会：

📥 接收当前输入 x_t（比如当前这个词）
🧠 回忆过去记忆 h_{t-1}（之前理解的内容）
🔄 更新当前理解 h_t（结合新信息和旧记忆）
📤 输出当前结果 y_t（基于完整理解的预测）

📊 RNN的数学表达（别怕，很简单！）

h_t = tanh(W_hh × h_{t-1} + W_xh × x_t + b_h)
y_t = W_hy × h_t + b_y

翻译成人话：

h_t：当前时刻的"理解状态"（记忆）
tanh：激活函数（给神经元装个"性格"）
W_hh：记忆权重（多重视过去的经验）
W_xh：输入权重（多重视当前信息）
W_hy：输出权重（如何基于理解做决策）

简单总结：新理解 = 过去记忆 + 当前输入 + 一点数学魔法✨

🎯 RNN的典型应用：从聊天到预测

💬 语言理解与生成

文本分类（情感分析）

任务： 判断"这部电影真的很棒，我推荐大家去看！"是正面还是负面评价

RNN处理过程：

“这部” → 理解：在讨论某个事物
“电影” → 更新理解：在讨论电影
“真的很棒” → 更新理解：这是正面评价！
“推荐” → 确认理解：确实是正面的

机器翻译

任务： “我爱学习” → “I love learning”

RNN处理：

编码器RNN：理解中文句子的含义
解码器RNN：根据理解生成英文

📈 时间序列预测

股价预测

历史数据： [100, 102, 98, 105, 103, …]
RNN学习： 股价的变化趋势和模式
预测： 下一天可能的价格

天气预测

历史数据： [温度、湿度、风速、气压…]
RNN学习： 天气变化的规律
预测： 明天的天气情况

🎵 创意生成

音乐创作

训练： 喂给RNN大量音乐作品
学习： 音符之间的关系和音乐规律
创作： 生成新的旋律

诗歌创作

训练： 学习古诗词的格律和韵律
创作： 生成符合格律的新诗

😰 RNN的"阿尔兹海默症"：梯度消失问题

虽然RNN很强大，但它有个致命弱点：记忆力不持久！

🤯 梯度消失：记忆的噩梦

想象RNN是个健忘的老人：

短期记忆OK： 能记住刚才说的几句话
长期记忆NG： 完全忘记了开头说了什么

技术原因：
当序列很长时，梯度在反向传播过程中会越来越小，最终接近于0，导致网络无法学习长期依赖关系。

实际表现：

能理解"我饿了，想吃饭"（短序列）
搞不懂"我早上7点起床，刷牙洗脸，然后…（中间100个词）…所以现在很饿"（长序列）

💡 解决方案预告

为了解决这个问题，科学家们发明了RNN的"升级版"：

LSTM（长短期记忆网络）：专门解决遗忘问题
GRU（门控循环单元）：LSTM的简化版

我们下次详细讲！

🛠️ 实战时间：用RNN预测股价

让我们用Python搭建一个简单的RNN来预测股价：

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

class SimpleRNN(nn.Module):
    def __init__(self, input_size=1, hidden_size=32, output_size=1, num_layers=2):
        super(SimpleRNN, self).__init__()
        
        # RNN层
        self.rnn = nn.RNN(
            input_size=input_size,      # 输入特征数
            hidden_size=hidden_size,    # 隐藏状态大小  
            num_layers=num_layers,      # RNN层数
            batch_first=True           # 批次优先
        )
        
        # 输出层
        self.fc = nn.Linear(hidden_size, output_size)
        
    def forward(self, x):
        # x shape: (batch_size, sequence_length, input_size)
        
        # RNN前向传播
        rnn_out, hidden = self.rnn(x)
        # rnn_out shape: (batch_size, sequence_length, hidden_size)
        
        # 只要最后一个时间步的输出
        predictions = self.fc(rnn_out[:, -1, :])
        # predictions shape: (batch_size, output_size)
        
        return predictions

# 创建模型
model = SimpleRNN(input_size=1, hidden_size=32, output_size=1)

# 模拟股价数据  
def generate_stock_data(seq_length=30, num_samples=1000):
    """生成模拟股价数据"""
    prices = []
    for _ in range(num_samples + seq_length):
        if len(prices) == 0:
            price = 100  # 起始价格
        else:
            # 随机游走 + 一点趋势
            change = np.random.normal(0, 1) + 0.01 * np.sin(len(prices) / 50)
            price = prices[-1] + change
        prices.append(price)
    
    return np.array(prices)

# 准备训练数据
def create_sequences(data, seq_length):
    """创建序列数据"""
    X, y = [], []
    for i in range(len(data) - seq_length):
        X.append(data[i:i+seq_length])
        y.append(data[i+seq_length])
    return np.array(X), np.array(y)

# 生成数据
stock_prices = generate_stock_data()
X, y = create_sequences(stock_prices, seq_length=30)

# 转换为PyTorch张量
X = torch.FloatTensor(X).unsqueeze(-1)  # 添加特征维度
y = torch.FloatTensor(y)

print(f"输入形状: {X.shape}")  # (样本数, 序列长度, 特征数)
print(f"输出形状: {y.shape}")  # (样本数,)

# 简单训练循环示例
criterion = nn.MSELoss()
optimizer = torch.optim.Adam(model.parameters(), lr=0.001)

# 训练几个epoch
for epoch in range(100):
    optimizer.zero_grad()
    predictions = model(X[:800])  # 用前800个样本训练
    loss = criterion(predictions.squeeze(), y[:800])
    loss.backward()
    optimizer.step()
    
    if epoch % 20 == 0:
        print(f'Epoch {epoch}, Loss: {loss.item():.4f}')

# 测试预测
model.eval()
with torch.no_grad():
    test_predictions = model(X[800:900])
    test_loss = criterion(test_predictions.squeeze(), y[800:900])
    print(f'Test Loss: {test_loss.item():.4f}')