GCN-LSTM交通预测实战：从原理到数据处理的完整解析

简介：面向智能交通时空预测与图神经网络应用，这套资料提供GCN-LSTM组合模型的完整Python实现和配套数据集，适合有深度学习基础、想快速复现时空预测实验的研究者。包内共74个文件，含Python源码、CSV数据、配置文件、示例图片等，压缩包约2MB，代码按数据读取、预处理、模型构建、训练评估等模块组织。数据集取自深圳2015年1月出租车轨迹，以罗湖区156条主要道路为研究区域，给出156×156邻接矩阵和每15分钟的道路速度特征矩阵，可直接作为GCN、GNN、LSTM等模型的输入。已有4060人学习下载，省去数据准备时间，便于专注验证模型效果，是交通流预测与路网时空建模的实用参考。

1. 为何交通预测这类问题最后都绕不开 GCN-LSTM

一个常见的预测场景：路网上分布着上百个检测器，每 5 分钟上报一次平均车速，业务方要的是“未来 15 分钟会不会堵”。如果只用 LSTM 逐条检测器做预测，等于假设每个检测器是独立世界里的个体——上游刚发生事故的车速骤降，下游的模型一无所知。而 GCN-LSTM 的核心价值，正是把“路网结构”显式编进模型：检测器是图节点，路段连通关系或空间距离是边，GCN 在每一层聚合邻居节点的状态，LSTM 再沿时间轴捕捉趋势，两者叠加得到真正意义上的时空预测模型。这个方向适合手里有传感器网络数据的从业者，也适合论文复现和算法岗面试手撕；难点不在模型本身，而在数据集准备和邻接矩阵构造，这两步直接决定模型是涨点还是翻车。本文按“原理 → 数据 → 代码 → 避坑”顺序把整条链路跑通。

2. GCN 与 LSTM 各自在建模什么，以及两种主流组合方式

2.1 GCN 的本质：在图上做邻域特征聚合

图卷积网络处理的对象不是规则网格（图像）或序列（文本），而是任意拓扑的图。核心操作是：每一层把某个节点的特征和它邻居节点的特征做加权求和，再经过一个线性变换和非线性激活。写成矩阵形式就是：

H^(l+1) = ReLU(A_hat · H^(l) · W^(l))

其中 A_hat 是归一化后的邻接矩阵，H^(l) 是第 l 层的节点特征矩阵，W^(l) 是可学习的权重矩阵。最关键的是 A_hat 的构造：先在原始邻接矩阵 A 上加上单位阵 I（自环），保证节点自身的特征在聚合时不被稀释；再计算度矩阵 D，用 D^(-1/2) · A_hat · D^(-1/2) 做对称归一化。归一化能避免中心节点（度很大）的特征被邻居数量淹没，也避免低度节点的特征在多层传播后消失。

GCN 的“感受野”由层数决定。一层 GCN 只聚合 1 跳邻居的信息，两层就能感知 2 跳范围。在交通场景里，这意味着“这个路口能不能感知到两公里外上游的拥堵”，取决于你堆了几层 GCN。但要注意，层数不是越多越好，GCN 加深以后节点特征会趋向一致，这就是后文要讲的过平滑问题。我处理过的场景里，路网数据一层 GCN 通常已经够用，更多时候应该去调整邻接矩阵的构建方式。

2.2 LSTM 在时间维度上做什么

LSTM 的输入是一个时间窗口内的观测序列，通过遗忘门、输入门、输出门控制信息保留与丢弃。门控机制让梯度可以在较长的时间步上回传，缓解普通循环神经网络的梯度消失。对检测器速度这类数据而言，LSTM 能学到“连续几个采样周期的下降趋势往往意味着拥堵开始”，也能记住“早高峰 8 点前的低速状态通常会持续一段时间”。

LSTM 本身不关心空间关系。如果直接把上百个检测器的数据拼成一个高维向量喂给它，它会学到节点之间统计上的相关性，但这种相关性是隐式的、黑匣子式的，而且当某个检测器失效或布局变化时，模型需要重新训练才能适应。这也是为什么要显式引入图结构。

2.3 两种组合结构：并行融合与串行级联

GCN-LSTM 不是唯一的写法，常见的组合方式有三种，我整理了一张对比表。

我通常选“先 GCN 后 LSTM”。理由很实际：每个时间步先做一次空间聚合，等于先把“此刻哪些邻居在影响我”这件事编码进当前帧，LSTM 接收到的就是一个空间增强的时间序列，避免了 LSTM 自己去猜节点间的耦合关系。下面的代码实现也按这个结构展开，你可以对照表里其他两种结构自行改写。

3. 拿到数据集后先做这三件事：构造邻接矩阵、滑动窗口、按时间切分

3.1 选择适合 GCN-LSTM 的公开数据集

GCN-LSTM 需要的数据集必须同时具备三样东西：空间坐标或图拓扑、连续时间采样、明确的预测目标。我在实际筛选数据时遇到过大量“只有表格没有坐标”“坐标全了但时间断档严重”的坑。行业内常用的公开数据集有几类：一类是高速公路传感器网络数据，常见配置是 200 个左右的检测点、5 分钟采样间隔、连续数月的平均车速记录，通常还附带每个传感器的经纬度；另一类是城市路网级别的检测数据，节点数在 300 上下，时间粒度为 5 分钟；还有一类是空气质量站点数据，每小时记录多种污染物浓度，站点数相对较少，适合用来先跑通代码。

选择时优先确认三件事：

• 数据里是否包含传感器坐标。没有坐标就无法计算距离并构造邻接矩阵，只能用别的方式定义边（比如路段连通关系），这会增加很多额外工作。
• 时间是否连续。如果数据里有大量缺失或完全不连续的时间段，填充难度远大于建模难度，建议换数据。
• 采样间隔是否统一。间隔不一致会导致滑动窗口内时间步的实际物理时长不同，LSTM 学到的“趋势”含义就乱了。

3.2 从坐标构造邻接矩阵的代码与参数

拿到传感器坐标后，最常用的做法是用高斯核函数把距离转成边的权重，同时用 K 近邻限制每个节点的邻居数量，避免邻接矩阵过于稠密。

import numpy as np import pandas as pd def build_adjacency_matrix(coords, sigma2=0.1, k=10): """ 根据节点坐标构造带权邻接矩阵 coords: shape [num_nodes, 2], 每行是 (x, y) 或 (longitude, latitude) sigma2: 高斯核的方差参数, 控制距离衰减速度 k: 每个节点保留的最近邻居数(含自身) """ num_nodes = coords.shape[0] # 计算节点两两之间的欧氏距离 diff = coords[:, None, :] - coords[None, :, :] # [N, N, 2] dist_sq = np.sum(diff ** 2, axis=-1) # [N, N] # 用高斯核计算相似度 # dist_sq 比较大的时候 exp(-d^2 / sigma2) 会迅速衰减到接近 0 adj = np.exp(-dist_sq / sigma2) # 每个节点只保留最近的 k 个邻居(含自身) # 思路: 按行排序, 距离排第 k+1 位之后的全部置 0 idx_sorted = np.argsort(dist_sq, axis=-1) mask = np.zeros_like(adj, dtype=bool) for i in range(num_nodes): mask[i, idx_sorted[i, :k]] = True adj = adj * mask # 加自环并做对称归一化: D^(-1/2) * (A + I) * D^(-1/2) adj = adj + np.eye(num_nodes) deg = np.sum(adj, axis=1) deg_inv_sqrt = np.power(deg, -0.5) deg_inv_sqrt[np.isinf(deg_inv_sqrt)] = 0.0 deg_inv_sqrt_mat = np.diag(deg_inv_sqrt) adj_normalized = deg_inv_sqrt_mat @ adj @ deg_inv_sqrt_mat return adj_normalized

这段代码里最容易忽略的是 sigma2 和 k 的联动关系。sigma2 设得太大，远距离节点之间的权重衰减不明显，邻接矩阵近似全连接，GCN 的空间聚合就失去了局部性；设得太小，距离稍远的邻居权重几乎为 0，等于把邻居数降到了 1 到 2 个。我的经验是先按坐标的尺度粗估：如果节点平均间距是 0.5 公里，sigma2 可以先试 0.1；然后查一下构造出来的邻接矩阵每行有效权重数量，太少就调大 sigma2 或增大 k。

3.3 滑动窗口构造训练样本和按时间切分

时间序列预测的样本不能用随机打乱的方式生成，必须保持时间先后关系。我一般先读入原始数据，得到一个 shape 为 [T, N] 的矩阵，T 是时间步数，N 是节点数，然后按 lookback 窗口切出输入和预测目标。

def create_sequences(data, lookback=12, horizon=3): """ data: shape [T, N], 已经按时间排序 lookback: 用过去多少个时间步进行预测 horizon: 预测未来多少个时间步 """ X, y = [], [] num_samples = len(data) - lookback - horizon + 1 for i in range(num_samples): X.append(data[i : i + lookback]) # [lookback, N] y.append(data[i + lookback : i + lookback + horizon]) # [horizon, N] X = np.array(X) # [num_samples, lookback, N] y = np.array(y) # [num_samples, horizon, N] return X, y

注意 y 的构造不只是未来一个时间步，而是返回整个 horizon 长度的序列，让模型一次直接输出多步预测。这样比递归预测（把预测值当输入再喂回去）稳定很多。在切分训练集和测试集时，必须严格按时间顺序切，比如前 70% 做训练，中间 15% 做验证，最后 15% 做测试，不能在样本维度上随机 shuffle。很多人在这里踩坑：时间序列样本之间本来就有重叠，如果随机切分，训练集和测试集共享了大量时间步信息，评估出来的指标虚高，上线后立刻翻车。

4. 从零搭一个可运行的 GCN-LSTM 模型

4.1 数据加载与标准化

先写数据加载和预处理模块。这里的关键点有两个：缺失值处理方式，以及标准化参数的来源。

import torch from torch import nn from torch.utils.data import Dataset, DataLoader class TrafficDataset(Dataset): """ 构造 Dataset, 输入 X 和 y 都是 numpy 数组 """ def __init__(self, X, y): self.X = torch.FloatTensor(X) self.y = torch.FloatTensor(y) def __len__(self): return len(self.X) def __getitem__(self, idx): return self.X[idx], self.y[idx] def load_and_prepare(csv_path, lookback=12, horizon=3): # csv 格式: 第一列是时间戳, 其余列是各节点的观测值 df = pd.read_csv(csv_path, index_col=0) # 交通数据里缺失值常用 -1 或 NaN 标记 df = df.replace(-1, np.nan) # 线性插值填充缺失 df = df.interpolate(method='linear', limit_direction='both') values = df.values # shape [T, N] # z-score 标准化 mean = np.mean(values, axis=0, keepdims=True) std = np.std(values, axis=0, keepdims=True) std[std == 0] = 1.0 # 避免常数列除零 values = (values - mean) / std X, y = create_sequences(values, lookback, horizon) return X, y, mean, std

标准化时反复强调：mean 和 std 只能来自训练集，不能用整个数据集的统计量。上面的代码为了方便展示把 mean 和 std 设在完整数据上计算了，实际项目里应该在读入后先把前 70% 的部分单独拿出来算统计量，再应用到全部数据。数据泄露在这个环节最容易发生，几乎每个刚接触时序预测的人都会犯一次。X 的最终 shape 是 [样本数, lookback, N, 1]，因为每个节点每个时刻只有一个特征维度；如果你的原始数据是多种指标（比如速度、流量、占有率），最后一个维度会大于 1，模型输入需要相应调整。

4.2 模型主体：GCN 层与 LSTM 层结合

模型结构采用先 GCN 后 LSTM 的方式。每个时间步把 [B, N, F] 的批量数据送入 GCN 做空间聚合，输出 [B, T, N, hidden_gcn]，然后把节点维和时间步重组成 LSTM 的序列输入。

class GCNLayer(nn.Module): def __init__(self, in_features, out_features, adj_normalized): super().__init__() self.register_buffer('adj', torch.FloatTensor(adj_normalized)) self.weight = nn.Parameter(torch.FloatTensor(in_features, out_features)) nn.init.xavier_uniform_(self.weight) def forward(self, x): # x: [batch, num_nodes, in_features] # 聚合邻居信息: [batch, num_nodes, num_nodes] @ [batch, num_nodes, in_features] x = torch.matmul(self.adj, x) x = torch.matmul(x, self.weight) return torch.relu(x) class GCNLSTM(nn.Module): def __init__(self, num_nodes, in_dim, hidden_gcn, hidden_lstm, out_steps, adj_normalized, dropout=0.2): super().__init__() self.num_nodes = num_nodes self.gcn = GCNLayer(in_dim, hidden_gcn, adj_normalized) self.lstm = nn.LSTM( input_size=hidden_gcn, hidden_size=hidden_lstm, num_layers=1, batch_first=True, dropout=0.0 ) self.fc = nn.Linear(hidden_lstm, out_steps) self.dropout = nn.Dropout(dropout) def forward(self, x): # x: [batch, lookback, num_nodes, in_dim] B, T, N, F = x.shape # 把 batch 和 time 折叠, 一次性对每个时间步做 GCN x = x.reshape(B * T, N, F) x = self.gcn(x) # [B*T, N, hidden_gcn] x = self.dropout(x) x = x.reshape(B, T, N, -1) # 恢复序列结构 # 重新排列为 [B, N, T, hidden_gcn], 再折叠成 LSTM 的 batch x = x.permute(0, 2, 1, 3) # [B, N, T, H] x = x.reshape(B * N, T, -1) # 每个节点是一条独立序列 out, _ = self.lstm(x) # [B*N, T, hidden_lstm] out = out[:, -1, :] # 取最后一个时间步 out = self.dropout(out) out = self.fc(out) # [B*N, out_steps] return out.reshape(B, N, -1)

forward 里的维度转换是这个模型最容易写错的地方。GCN 层接收的是 [节点数, 特征数] 的结构，所以要把 batch 和时间步临时折叠成一个维度；LSTM 接收的序列维度是 [batch, 序列长度, 特征]，这里每个节点被视为一个独立的序列样本，所以把 [B, N, T, H] 重排成 [B*N, T, H]。写代码时如果不注意 contiguous 和 permute 的配合，PyTorch 会报维度错误或者悄悄产生错误的张量布局。初始化用 xavier_uniform_，LSTM 的 hidden_lstm 我一般设为 32 或 64，太小欠拟合，太大在节点数上百时训练明显变慢。

4.3 训练循环、早停与指标评估

训练部分要处理好两件事：梯度裁剪防止 LSTM 梯度爆炸，早停防止过拟合。损失函数用 MSE，评估时再看 MAE 和 RMSE。

import torch.optim as optim def train_model(model, train_loader, val_X, val_y, epochs=100, lr=1e-3): optimizer = optim.Adam(model.parameters(), lr=lr, weight_decay=1e-4) criterion = nn.MSELoss() # 用余弦退火调整学习率 scheduler = optim.lr_scheduler.CosineAnnealingLR(optimizer, T_max=epochs) best_loss = float('inf') best_state = None patience = 10 trigger = 0 for epoch in range(epochs): model.train() total_loss = 0.0 for X_batch, y_batch in train_loader: optimizer.zero_grad() pred = model(X_batch) loss = criterion(pred, y_batch) loss.backward() # LSTM 梯度尺度波动大, 裁剪到 norm=5 可以避免偶发的 NaN torch.nn.utils.clip_grad_norm_(model.parameters(), 5.0) optimizer.step() total_loss += loss.item() scheduler.step() # 验证集评估 model.eval() with torch.no_grad(): val_pred = model(torch.FloatTensor(val_X)) val_loss = criterion(val_pred, torch.FloatTensor(val_y)).item() if val_loss < best_loss: best_loss = val_loss best_state = {k: v.clone() for k, v in model.state_dict().items()} trigger = 0 else: trigger += 1 if trigger >= patience: break model.load_state_dict(best_state) return model

早停的 patience 我习惯给 10 到 15，学习率初始值给 1e-3。如果发现训练集 loss 降得很慢，优先检查数据标准化是否做了、GCN 的邻接矩阵归一化是否正确，而不是急着调学习率。LSTM 类模型对学习率很敏感，1e-2 往往直接发散，1e-4 又慢得让人失去耐心。余弦退火 schedule 配合早停用，后期 loss 曲线会平稳很多，不容易在最优解附近震荡。评估阶段除了 MSE，建议同时算 MAE 和 RMSE，交通预测的业务汇报里这几个数字都要给。

5. GCN-LSTM 调参避坑：5 个我反复踩过的实际问题

5.1 邻接矩阵没加自环或归一化顺序不对，模型收敛极慢甚至不收敛

现象：训练 loss 在几十个 epoch 里几乎不下降，或者下降后迅速停在某个很高位。

原因：最常见的是 A + I 和归一化的顺序搞反。有些人先对原始 A 做 D^(-1/2) A D^(-1/2)，然后再加单位阵，这样对角元的权重没有被正确归一化，自环在数值上会主导聚合结果，等于模型只学到每个节点自己的历史，空间信息被压制住了。另外，没有加自环时，每经过一层 GCN，节点自己的信息就被邻居稀释一次，多层以后特征幅度越来越小，梯度也传不回去。

解决：严格按代码里的顺序：先加单位阵，再算度矩阵，再做对称归一化。建议把归一化后的矩阵打印出来检查：对角线应该接近 0.5 到 1.0 之间，非对角线元素都比对角线小。

5.2 标准化统计量用了全量数据，验证集指标虚高

现象：验证集上 MAE 好看得惊人，甚至比训练集还低，但模型部署到线上新数据后效果断崖式下跌。

原因：整个数据集共享了同一对 mean 和 std，等于验证集和测试集的信息在预处理阶段被模型“看到”了。时间序列的样本窗口高度重叠，这个问题比非时序数据更隐蔽，因为数值上一切正常，只有回到真实业务流里才会暴露。

解决：只用时间上最早的那部分训练数据计算 mean 和 std，保存成变量，后续所有数据集都用这一对参数。宁可让验证集统计分布和训练集有轻微偏移，也不能让验证集的信息提前进入预处理。

5.3 LSTM 的输入维度顺序搞反，前向传播直接 NaN

现象：模型能跑通，但 loss 输出是 nan，或者训练一两步后参数变成 nan。

原因：PyTorch 的 LSTM 默认要求输入 shape 为 [seq_len, batch, features]，但我代码里设了 batch_first=True，此时输入应该是 [batch, seq_len, features]。最典型的手误是用 reshape 而不是 permute，把 [B, T, N, H] 硬重新解释成 [B*N, T, H]，维度的物理含义全错。

解决：reshape 和 permute 的分工要拎清。permute 只交换维度顺序不改变数据布局，reshape 是对内存中的数据进行重新解释。代码里“先 permute 再 reshape”的顺序不能乱，并且在 reshape 后加一句断言（比如 [B, N, T, H] 折成 [BN, T, H] 之前，先确认真实 shape 是 BN 行而不是 N 行），能省很多调试时间。

5.4 GCN 层数一多就过平滑，预测曲线变成“一条直线”

现象：GCN 从 1 层加到 3 层后，验证集 loss 显著变差，把预测结果可视化，发现所有节点的预测值几乎一样。

原因：多层 GCN 不断聚合邻居信息，感受野成倍扩大，到第 3 层时每个节点已经聚合了大量跨距离节点的特征，节点的个性化信息被平均掉了。这在交通路网上尤其明显，因为路网本身连通性强，多跳邻居很快覆盖全图。

解决：默认从 1 层 GCN 开始调。如果你的业务场景确实需要感知远距离影响，优先增大邻接矩阵里的 k（近邻数量）而不是堆 GCN 层数。k 从 10 增大到 20，效果往往比多叠一层 GCN 好，而且数值更稳定。

5.5 按样本维度随机切分数据，把未来的信息泄漏给过去

现象：模型在测试集上指标非常好，但新数据到场后预测完全不准。

原因：我把训练集、验证集、测试集直接从样本数组里随机打乱切分了。滑动窗口产生的样本相互重叠，比如第 1 个样本覆盖 [0:12] 时刻，第 2 个样本覆盖 [1:13] 时刻，随机打乱后测试集里混入了与训练样本高度重合的时间段。模型本质上是在“背答案”。

解决：切分必须在时间序列的最外层进行。先把原始时间序列 [T, N] 按前 70%、中间 15%、最后 15% 切成三段，再分别对每段做滑动窗口。这样三个数据集之间完全没有时间重叠，评估出来的指标才是真实的。

6. 多步预测输出方式与一个提升明显的诊断技巧

关于多步预测，我强烈建议在主模型里把最后输出层改成直接输出 horizon 个时间步的值，而不是训练一个单步模型然后递归预测。递归预测时，第 2 步的输入是第 1 步的输出，误差逐级放大，尤其在预测拥堵开始和消散这种拐点附近，递归误差会被放大成相位偏移。直接多步输出虽然会让模型一次要拟合多个目标，训练难度略增，但实际部署时稳定得多，指标也更好看。你可以在验证集上把两种方式对比一次，大概率会直接放弃递归思路。

另外一个值得养成的习惯：在搭完整模型之前，先做一个空间相关性的快速诊断。取两个空间距离最近的节点，计算它们时间序列的皮尔逊相关系数；再取两个距离最远的节点，同样算一下。如果距离近的节点相关系数也低，说明这个数据集里空间结构对目标变量的影响很弱，那么 GCN 加进来大概率不会涨点。反过来，如果相关系数随距离衰减明显，GCN 的收益会非常显著。这个检查只需要几行代码和一分钟时间，但它能帮你避免在错误的数据上反复调参。我现在的习惯是先跑一个纯 LSTM 的 baseline，记录指标，再叠加 GCN；GCN 相对提升如果不到 15%，我会回头检查邻接矩阵构造而不是继续堆模型复杂度。希望这篇实战拆解能帮你在 GCN-LSTM 这条路上少走几个弯路。

本文还有配套的精品资源，点击获取