PyTorch实战：RNN与LSTM时间序列预测全流程解析

本篇文章是 PyTorch 实战系列的第 41 篇。这次要处理的对象不是图像，而是序列数据，核心是循环神经网络（RNN）和长短期记忆网络（LSTM）。文本、语音、股票价格、传感器读数、视频帧都可以被看作序列，而 RNN 和 LSTM 正是处理这类数据的基础结构。

先说清楚这篇文章要做什么：先用公式讲明白标准循环神经网络（Vanilla RNN）在时间步 t 的隐藏状态更新逻辑，再用 PyTorch 手写一遍 RNN 核心计算；然后分别用nn.RNN和nn.LSTM完成一个可运行的时间序列预测项目，涵盖数据构造、训练、评估、模型保存和单步推理；最后给出训练过程中的常见报错和排查方法。整个流程可以在 CPU 上跑通，有 NVIDIA GPU 也能直接用，不挑显卡。

核心特点归纳为四个：第一，代码可直接运行，数据用正弦波构造，不依赖外部数据集；第二，同时覆盖 RNN 和 LSTM 两种结构，方便对比；第三，既有公式推导也有 PyTorch 源码实现，适合理解原理；第四，给出了批量训练、模型保存和单步预测的完整工程模板。适合正在学习 PyTorch、想弄明白循环神经网络工作原理、或者需要快速上手序列建模的开发者。

1. 核心能力速览

2. 循环神经网络与 LSTM 基础概念

循环神经网络的核心思想是“共享权重处理变长序列”。传统全连接网络处理一条长度为 T 的序列时，通常需要把整条序列拼成一个固定长度的向量，这样会丢失时间维度上的顺序信息。RNN 的做法是在每个时间步 t 维护一个隐藏状态 h_t，这个状态既接收当前输入 x_t，也接收上一个时间步的隐藏状态 h_{t-1}。它们的核心公式就是：

h_t = tanh(W_ih @ x_t + b_ih + W_hh @ h_{t-1} + b_hh) y_t = W_ho @ h_t + b_ho

第一个公式就是标准循环神经网络（Vanilla RNN）在时间步 t 的隐藏状态更新。W_ih 是输入到隐藏层的权重，W_hh 是隐藏层到隐藏层的权重，b_ih 和 b_hh 是偏置。tanh 在这里充当非线性激活函数，帮助把状态值压缩到 -1 到 1 之间。第二个公式把隐藏状态映射成输出。

这个设计能够处理变长序列的原因在于，无论序列多长，模型始终只用这一组权重 W_ih、W_hh 循环计算。参数数量不随序列长度变化。从输入角度看，x_t 是时间步 t 的特征向量，例如文本中第 t 个词的词向量、语音中第 t 帧的 MFCC 特征、股票第 t 天的特征序列。

不过 Vanilla RNN 有一个明确短板：当序列较长时，梯度在反向传播过程中经过多次连乘会快速缩小，出现梯度消失。网络因此难以记住几十个时间步之前的信息，这就是所谓的长期依赖问题。LSTM（长短期记忆网络）就是为了解决这个问题出现的。LSTM 在隐藏状态之外额外引入了一个细胞状态 c_t，并用输入门、遗忘门、输出门来控制信息的写入、保留和输出。更新公式如下：

i_t = σ(W_ii @ x_t + b_ii + W_hi @ h_{t-1} + b_hi) f_t = σ(W_if @ x_t + b_if + W_hf @ h_{t-1} + b_hf) g_t = tanh(W_ig @ x_t + b_ig + W_hg @ h_{t-1} + b_hg) o_t = σ(W_io @ x_t + b_io + W_ho @ h_{t-1} + b_ho) c_t = f_t ⊙ c_{t-1} + i_t ⊙ g_t h_t = o_t ⊙ tanh(c_t)

其中 σ 表示 sigmoid 函数，⊙ 表示逐元素相乘。遗忘门 f_t 决定上一时刻的细胞状态被保留多少，输入门 i_t 决定当前新信息写入多少，输出门 o_t 决定当前隐藏状态输出多少。细胞状态 c_t 的更新是一条“加法”路径：旧状态先乘遗忘门，再累加新信息。这种设计让梯度可以通过细胞状态直接向后传播，有效缓解梯度消失，这就是 LSTM 的核心价值。

从使用角度来说，RNN 更适合快速验证序列建模流程、参数量要求低的场景；LSTM 是更稳定的默认选择。两者的适用边界也很清楚：如果序列较短，比如几十个时间步，Vanilla RNN 也可以完成任务；如果序列长度上百甚至上千，直接选 LSTM 或 GRU 更稳妥。

3. 环境准备与 PyTorch 安装

这次实战需要 Python 环境和 PyTorch。PyTorch 的安装方式直接决定后面能否顺利跑通模型，因此先把安装步骤单独说明。常见的方式是通过 Conda 创建独立环境，避免和系统其他项目互相污染依赖。

如果本机没有安装 Anaconda 或 Miniconda，建议先安装 Miniconda，然后把环境创建和 PyTorch 安装一起完成。CPU 版本适合快速验证代码逻辑，GPU 版本适合训练规模更大的模型。具体命令模板如下：

# 创建 Python 3.10 环境 conda create -n pytorch-rnn python=3.10 -y conda activate pytorch-rnn # CPU 版 PyTorch pip install torch torchvision torchaudio # CUDA 12.1 版 PyTorch（按本机 CUDA 驱动版本调整） # pip install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu121

安装完成后，验证环境是否正常，使用如下命令：

import torch print(torch.__version__) print(torch.cuda.is_available())

第一次运行输出版本号，比如 2.x.x。torch.cuda.is_available()在无 GPU 机器上返回False，这不影响本文的练习，代码会退回到 CPU 计算。如果返回True，可以继续查看显卡名称和显存信息：

if torch.cuda.is_available(): print(torch.cuda.get_device_name(0)) print(torch.cuda.get_device_capability(0))

这里重点提醒一点：不要只关注 PyTorch 版本，要和 CUDA 驱动版本配合。如果驱动版本过旧，即使 PyTorch 安装成功，调用 GPU 时也会出现 “CUDA error: no kernel image is available” 这类报错。更稳妥的判断是，先确认显卡驱动支持哪个 CUDA 版本，再选择对应的 PyTorch 安装命令。

环境准备阶段的磁盘占用也需要留意。一个包含 PyTorch 的 Conda 环境通常占用 3GB 到 6GB 空间，如果装了 CUDA 相关的运行库，总占用可能到 8GB 以上。建议至少预留 10GB 空间。

4. 数据准备：用正弦波构造时间序列预测任务

为了把注意力集中在循环神经网络本身，本次使用正弦波数据做时间序列预测。正弦波是周期性信号，适合观察 RNN 和 LSTM 的记忆能力。比如输入前 12 个时间步的数值，预测第 13 个时间步的值，相当于一个回归任务，可以用 MSE（均方误差）作为损失函数。

首先构造原始序列：

import numpy as np import torch from torch.utils.data import Dataset, DataLoader # 生成正弦波数据 np.random.seed(42) torch.manual_seed(42) x = np.linspace(0, 100, 2000) data = np.sin(x) + 0.05 * np.random.randn(len(x))

这里np.linspace(0, 100, 2000)生成 2000 个点，sin 函数保证周期结构，后面加的小幅噪声让任务难度更接近真实场景。接下来把连续序列切成长度为seq_len的输入样本和对应的标签。传统做法是用滑动窗口切分：窗口内有 12 个点，则第 13 个点作为标签。

def create_sequences(data, seq_len=12): xs, ys = [], [] for i in range(len(data) - seq_len): xs.append(data[i:i + seq_len]) ys.append(data[i + seq_len]) return np.array(xs, dtype=np.float32), np.array(ys, dtype=np.float32) seq_len = 12 X, y = create_sequences(data, seq_len) print(X.shape, y.shape)

输出结果应当是(1988, 12)和(1988,)。随后切分训练集和测试集。这里按照时间顺序切分，而不是随机切分，因为时间序列数据相邻样本之间有顺序依赖，随机切分会造成信息泄露。训练集用前 80%，测试集用最后 20%。

train_size = int(len(X) * 0.8) X_train, X_test = X[:train_size], X[train_size:] y_train, y_test = y[:train_size], y[train_size:]

为了给后续DataLoader使用，需要把数组包装成 dataset 对象。为了展示 PyTorch 批量训练的完整流程，这一层用类包装：

class SinDataset(Dataset): def __init__(self, X, y): self.X = torch.from_numpy(X) self.y = torch.from_numpy(y) def __len__(self): return len(self.X) def __getitem__(self, idx): return self.X[idx], self.y[idx] train_dataset = SinDataset(X_train, y_train) test_dataset = SinDataset(X_test, y_test) batch_size = 64 train_loader = DataLoader(train_dataset, batch_size=batch_size, shuffle=True) test_loader = DataLoader(test_dataset, batch_size=batch_size, shuffle=False)

DataLoader内部会自动把一个批次的数据堆叠成形状为(batch_size, seq_len)的张量。后面给模型输入时，还需要增加一个特征维度，变成(batch_size, seq_len, 1)，这一步可以在模型内部完成，也可以在数据加载时处理。本系列代码统一放在模型初始化部分，这样数据层只负责原始数据的读取和切分。

5. 从零实现 Vanilla RNN 核心计算

理解 RNN 最快的方式是实现一遍它的前向传播。虽然 PyTorch 提供了nn.RNN，但先用普通张量运算把核心公式写出来，可以清楚看到权重在每个时间步是如何参与计算的。下面这个类直接用nn.Parameter定义权重和偏置，不依赖nn.RNN：

import torch.nn as nn import torch.nn.functional as F class VanillaRNNCell(nn.Module): def __init__(self, input_size, hidden_size): super().__init__() self.input_size = input_size self.hidden_size = hidden_size # 输入 -> 隐藏层 self.W_ih = nn.Parameter(torch.randn(input_size, hidden_size) * 0.01) # 隐藏层 -> 隐藏层 self.W_hh = nn.Parameter(torch.randn(hidden_size, hidden_size) * 0.01) # 偏置 self.b_ih = nn.Parameter(torch.zeros(hidden_size)) self.b_hh = nn.Parameter(torch.zeros(hidden_size)) def forward(self, x, h_prev): # x: (batch_size, input_size) # h_prev: (batch_size, hidden_size) h = torch.tanh( x @ self.W_ih + self.b_ih + h_prev @ self.W_hh + self.b_hh ) return h

forward接收当前时间步的输入x和上一个隐藏状态h_prev，输出新的隐藏状态h。@是矩阵乘法运算符。权重初始化为 0.01 倍的标准正态分布，偏置初始化为 0，这是比较保守的初始化方式，可以避免训练早期出现梯度爆炸。

接下来写一个封装类，让它自动按时间步展开。输入形状是(batch_size, seq_len, input_size)，输出每个时间步的隐藏状态：

class VanillaRNN(nn.Module): def __init__(self, input_size, hidden_size): super().__init__() self.cell = VanillaRNNCell(input_size, hidden_size) self.hidden_size = hidden_size def forward(self, x): batch_size, seq_len, _ = x.shape h = torch.zeros(batch_size, self.hidden_size, device=x.device) outputs = [] for t in range(seq_len): x_t = x[:, t, :] h = self.cell(x_t, h) outputs.append(h) return torch.stack(outputs, dim=1)

这个类的作用是逐时间步迭代。torch.stack(outputs, dim=1)把所有时间步的隐藏状态按序列维度堆叠，最终输出形状为(batch_size, seq_len, hidden_size)。需要注意的是，这种 Python 循环写法在序列很长时会变慢，PyTorch 的nn.RNN在内部做了大量优化，因此实际项目中优先使用内置模块。手写版本主要用于理解公式。

训练这个模型之前，还需要在最后接一个全连接层，把隐藏状态映射成预测值。下面就会看到完整训练流程。

6. 使用 PyTorch 内置 RNN 实现时间序列预测

这一节把数据加载、Vanilla RNN 和训练流程串起来。为了简洁，直接使用torch.nn.RNN。输入数据形状为(batch_size, seq_len)，在送入模型之前需要升维为(batch_size, seq_len, 1)，因为nn.RNN期望每个时间步的特征维度为 1。

定义模型如下：

class RNNPredictor(nn.Module): def __init__(self, input_size=1, hidden_size=32, num_layers=1): super().__init__() self.rnn = nn.RNN( input_size=input_size, hidden_size=hidden_size, num_layers=num_layers, batch_first=True ) self.fc = nn.Linear(hidden_size, 1) def forward(self, x): # x: (batch_size, seq_len, 1) out, h_n = self.rnn(x) # out: (batch_size, seq_len, hidden_size) # 取最后一个时间步的输出 last_out = out[:, -1, :] return self.fc(last_out)

batch_first=True让输入和输出都采用(batch, seq, feature)的排列方式，符合绝大多数直接读数据的自然写法。out[:, -1, :]取出序列最后一个时间步的隐藏状态，再经过全连接层输出预测值。在这种“输入前 12 个点预测第 13 个点”的任务里，最后一个时间步的隐藏状态包含了对下一个点的预测所需信息。

接下来定义训练函数：

import torch.optim as optim device = torch.device("cuda" if torch.cuda.is_available() else "cpu") model = RNNPredictor(input_size=1, hidden_size=32, num_layers=1).to(device) criterion = nn.MSELoss() optimizer = optim.Adam(model.parameters(), lr=0.001) epochs = 50 for epoch in range(epochs): model.train() total_loss = 0.0 for X_batch, y_batch in train_loader: X_batch = X_batch.unsqueeze(-1).to(device).float() y_batch = y_batch.unsqueeze(-1).to(device).float() optimizer.zero_grad() output = model(X_batch) loss = criterion(output, y_batch) loss.backward() optimizer.step() total_loss += loss.item() * X_batch.size(0) avg_loss = total_loss / len(train_dataset) if (epoch + 1) % 10 == 0: print(f"RNN epoch {epoch + 1}/{epochs}, loss: {avg_loss:.6f}")

注意X_batch.unsqueeze(-1)把(batch_size, seq_len)变成(batch_size, seq_len, 1)。y_batch.unsqueeze(-1)把标签变成(batch_size, 1)，方便和模型输出计算 MSE。训练循环里最核心的四个操作是optimizer.zero_grad()、loss.backward()、optimizer.step()，顺序不能乱。每次反向传播前，优化器必须清空上一轮累积的梯度。

从实际训练效果来看，这个模型在正弦波任务上收敛很快。通常 10 个 epoch 后损失会明显下降，50 个 epoch 后已经能大致拟合正弦波走势。如果发现损失卡住不动，优先检查学习率是否过大、数据是否归一化以及隐藏层维度是否过低。

7. 使用 PyTorch LSTM 实现时间序列预测

LSTM 的工程写法几乎和 RNN 一样，只要把nn.RNN替换成nn.LSTM即可。但需要注意一个细节：nn.LSTM返回的out, (h_n, c_n)多了一个细胞状态。单独取out时，代码结构和 RNN 版本一致。

class LSTMPredictor(nn.Module): def __init__(self, input_size=1, hidden_size=32, num_layers=1): super().__init__() self.lstm = nn.LSTM( input_size=input_size, hidden_size=hidden_size, num_layers=num_layers, batch_first=True ) self.fc = nn.Linear(hidden_size, 1) def forward(self, x): out, _ = self.lstm(x) last_out = out[:, -1, :] return self.fc(last_out)

这里_用来忽略(h_n, c_n)。h_n是最后一个时间步的隐藏状态，c_n是最后一个时间步的细胞状态。在这个回归任务里，直接用每个时间步输出的隐藏状态序列中的最后一个值即可。

训练代码和上一节几乎一致，只需要把模型类替换成LSTMPredictor：

model = LSTMPredictor(input_size=1, hidden_size=32, num_layers=1).to(device) criterion = nn.MSELoss() optimizer = optim.Adam(model.parameters(), lr=0.001) epochs = 50 for epoch in range(epochs): model.train() total_loss = 0.0 for X_batch, y_batch in train_loader: X_batch = X_batch.unsqueeze(-1).to(device).float() y_batch = y_batch.unsqueeze(-1).to(device).float() optimizer.zero_grad() output = model(X_batch) loss = criterion(output, y_batch) loss.backward() optimizer.step() total_loss += loss.item() * X_batch.size(0) avg_loss = total_loss / len(train_dataset) if (epoch + 1) % 10 == 0: print(f"LSTM epoch {epoch + 1}/{epochs}, loss: {avg_loss:.6f}")

从训练表现看，LSTM 和 RNN 在这个数据集上的 loss 差异通常不大，因为正弦波序列较短，只有 12 个时间步，梯度消失问题不严重，RNN 也能正常建模。要体现 LSTM 的优势，应把序列长度增加，比如seq_len=50或seq_len=100，或者在文本分类、语音识别这类长序列任务上对比。此时 LSTM 通常能保持更平稳的收敛过程，对远距离依赖的记忆能力更强。

训练结束后，可用测试集评估两个模型的性能，并计算测试集 MSE：

def evaluate(model, test_loader): model.eval() total_loss = 0.0 with torch.no_grad(): for X_batch, y_batch in test_loader: X_batch = X_batch.unsqueeze(-1).to(device).float() y_batch = y_batch.unsqueeze(-1).to(device).float() output = model(X_batch) loss = criterion(output, y_batch) total_loss += loss.item() * X_batch.size(0) return total_loss / len(test_dataset) print(f"RNN test MSE: {evaluate(rnn_model, test_loader):.6f}") print(f"LSTM test MSE: {evaluate(lstm_model, test_loader):.6f}")

测试时一定要进入model.eval()模式，并使用torch.no_grad()关闭梯度计算。这能节省显存和计算资源，同时避免 BatchNorm、Dropout 等层在推理时的行为不一致。

8. 模型保存、加载与单步推理

训练完成后的模型需要保存到磁盘。PyTorch 的推荐做法是保存state_dict，也就是只保存模型参数，不保存整个模型对象。这样后续加载时更灵活，也能避免 PyTorch 版本变化导致的兼容问题。

# 保存 LSTM 模型参数 torch.save(model.state_dict(), "lstm_predictor.pth") # 加载模型参数 model_load = LSTMPredictor(input_size=1, hidden_size=32, num_layers=1).to(device) model_load.load_state_dict(torch.load("lstm_predictor.pth", map_location=device)) model_load.eval()

这里map_location=device是为了在 GPU 上保存的模型也能在 CPU 机器上加载。模型结构定义必须和保存时一致，否则load_state_dict会抛 KeyError 或 size mismatch 错误。

接下来是单步推理。推理流程可以拆成“拼接历史序列 → 模型预测 → 输出下一个点”三个步骤。比如已经有一段长度为 12 的历史数据，想预测下一个时间点的数值：

def predict_next(model, history): # history: numpy array, shape (seq_len,) model.eval() x_tensor = torch.from_numpy(history).float().unsqueeze(0).unsqueeze(-1).to(device) with torch.no_grad(): pred = model(x_tensor) return pred.item() # 示例：取测试集第一段的前 12 个点，预测第 13 个点 sample_history = X_test[0] print("历史序列:", sample_history) print("真实下一个点:", y_test[0]) print("预测下一个点:", predict_next(model_load, sample_history))

unsqueeze(0)增加 batch 维度，unsqueeze(-1)增加特征维度。预测输出是一个形状为(1, 1)的张量，取出标量值即可。如果要做多步预测，可以把预测值追加到历史序列末尾，丢弃最前面的一个点，再用新的 12 个点预测下一个点。这种迭代式预测也叫递归多步预测，代码实现如下：

def predict_steps(model, history, steps=10): model.eval() history = list(history) predictions = [] for _ in range(steps): input_seq = np.array(history[-seq_len:], dtype=np.float32) pred = predict_next(model, input_seq) predictions.append(pred) history.append(pred) return np.array(predictions) # 从测试集起点向后预测 10 个点 multi_pred = predict_steps(model_load, X_test[0], steps=10) print("多步预测结果:", multi_pred)

递归多步预测的主要问题是误差会逐步累积。预测值越往后偏差越大，这是由模型不确定性和训练数据噪声共同导致的。实际项目中如果要多步预测，需要评估累计误差，必要时改用直接多步预测或引入其他校准方法。

9. 资源占用与训练性能观察

训练这类小型 RNN/LSTM 的资源占用并不高。单个隐藏层、hidden_size=32、batch_size=64，在 CPU 上跑 50 个 epoch 通常只需要几十秒，占用内存几百 MB。如果有 NVIDIA GPU，PyTorch 会自动调用 GPU 加速，但显存占用对这个任务来说通常不超过几百 MB，具体数值要看 batch_size、序列长度和隐藏层维度。

如果希望实时观察显存占用，可以使用如下命令。在 Windows 下用 nvidia-smi 配合任务管理器查看，在 Linux 下直接用 watch 命令：

# 每 1 秒刷新一次显存信息 watch -n 1 nvidia-smi

在训练循环里也可以用 PyTorch API 打印当前显存占用：

if torch.cuda.is_available(): print(f"显存分配: {torch.cuda.memory_allocated() / 1024 ** 3:.3f} GB") print(f"显存缓存: {torch.cuda.memory_reserved() / 1024 ** 3:.3f} GB")

memory_allocated()表示当前实际分配的显存，memory_reserved()表示 PyTorch 从驱动层缓存的总显存。两者之间的差异来自 PyTorch 的显存缓存池机制，不代表泄漏。

影响资源占用的主要因素有三个。第一是batch_size，它决定了一次前向和反向传播需要处理多少样本，显存和 batch_size 基本成正比。第二是seq_len，RNN 需要按时间步展开，序列越长，中间计算图越复杂，占用越高。第三是hidden_size和num_layers，它们决定权重矩阵规模和中间激活值的大小。降低显存占用的常用方法是减小 batch_size、降低 hidden_size、减少 num_layers、关闭梯度计算时使用torch.no_grad()。如果需要训练超长序列，还可以考虑梯度裁剪torch.nn.utils.clip_grad_norm_和梯度累积，这在 RNN 系列模型中尤其重要。

性能观察方面，RNN 的 Python 循环在 CPU 上较慢，PyTorch 内置nn.RNN和nn.LSTM内部有优化，实际训练速度比手写 Python 循环快。在 GPU 上使用 LSTM 时注意输入数据形状，batch_first=True在部分旧版本 PyTorch 中可能略有性能损耗，但新版本基本可忽略。

10. 常见问题与排查方法

如果遇到 “size mismatch for weight_ih_l0” 这类报错，说明加载权重时模型结构参数不一致。解决方案是检查保存和加载时的input_size、hidden_size和num_layers，保持一致。如果遇到 “Expected hidden[0] size” 报错，则是手动传入h_0或c_0时维度对不上，检查num_layers和batch_size即可。

11. 最佳实践与使用建议

训练 RNN 和 LSTM 时，有几点工程经验值得固定下来。

第一，数据归一化是一个关键步骤。正弦波数据本身值域在 -1 到 1 之间，不做归一化也能训练。但如果是真实业务数据，比如股票价格、温度传感器读数，数值范围差异可能很大。建议用sklearn.preprocessing.MinMaxScaler或StandardScaler把数据缩放到合理范围，训练完成后再把预测结果反向还原。这里给出一个归一化的参考写法：

from sklearn.preprocessing import MinMaxScaler scaler = MinMaxScaler(feature_range=(-1, 1)) data_scaled = scaler.fit_transform(data.reshape(-1, 1)).ravel()

第二，梯度裁剪是 RNN 训练的重要保护机制。序列模型的反向传播过程中梯度可能越来越大，最终导致 NaN。在 optimizer.step 之前加一步：

torch.nn.utils.clip_grad_norm_(model.parameters(), max_norm=1.0)

这个操作非常便宜，但能有效防止梯度爆炸。对于 LSTM 可以减小裁剪阈值，比如 0.5 或 1.0。

第三，日志记录和实验管理要尽早建立。建议把每次实验的 hidden_size、num_layers、learning_rate、batch_size、最终 loss 记录到一个字典或 CSV 文件中。不要手动改参数重跑，否则后期很难对比。可以用类似下面的结构：

config = { "model": "LSTM", "hidden_size": 32, "num_layers": 1, "learning_rate": 0.001, "batch_size": 64, "seq_len": 12, "epochs": 50, "test_mse": 0.0 }

第四，模型训练和推理要严格区分模式。训练时调用model.train()，推理时调用model.eval()。虽然当前模型没有 Dropout 和 BatchNorm，但从一开始养成习惯，后续换用复杂模型时不会踩坑。

第五，批量任务和接口服务场景下的注意事项。如果训练好的模型要接成全流程服务，可以把它封装成标准的 Python 类，对外暴露predict(history_array)方法。整个序列数据可以按天或按文件批量读取，每条序列独立调用模型，注意线程安全。模型加载一次后放在内存中，不要每次都重新加载，否则资源开销很大。服务部署时建议限制访问范围，当年级模型服务只监听内网地址即可。

第六，涉及文本、语音或人脸等真实数据时，必须确认数据来源的合法授权。序列模型经常被用在文本分类、语音识别、推荐系统等场景，如果训练数据来自用户，必须遵循隐私保护要求。这一点在工程落地的早期就要考虑，不能等上线的阶段。

12. 总结与下一步

这篇实战文章从标准循环神经网络的核心公式出发，先手写了 Vanilla RNN 的隐藏状态更新过程，再用 PyTorch 内置nn.RNN和nn.LSTM完成了正弦波时间序列预测任务。全文覆盖了环境安装、数据切分、批量训练、测试评估、模型保存和单步推理，基本就是一个小型序列建模项目的完整流程。

如果想快速验证代码，建议先用seq_len=12、hidden_size=32、batch_size=64跑一遍，确认流程没问题后再逐步增加序列长度和隐藏层维度。最容易踩的坑是数据切分泄漏、学习率过大导致 NaN、以及模型结构不一致导致加载权重报错。这三类问题在真实项目中非常常见，排查时优先检查数据、优化器参数和state_dict的维度和结构。

下一步可以尝试的方向：把序列长度增加到 100，对比 RNN 和 LSTM 的 loss 差异，验证 LSTM 在长序列上的优势；把正弦波换成真实业务数据，比如电力负荷、流量日志或股票行情；把模型结构从单层改成多层 LSTM，观察收敛速度和效果变化；也可以把序列建模方式迁移到文本分类任务，用同款结构处理 embedding 输入。循环神经网络的公式和工程代码掌握了，后续看 GRU、Transformer 中的位置编码和自注意力，就都能更快上手。