企业官网建设流程全解析

在智能交通领域做车辆路径优化，最核心的矛盾往往不是“算法不够聪明”，而是“数据在时刻变化，路径却在出发前就固定了”。无论是物流车队的配送调度，还是网约车的实时接单路线，只要交通流量预测跟不上实际情况，初始规划结果就很容易失真。对于准备计算机毕设的同学来说，把“交通流预测”和“路径动态优化”结合起来，是一个兼顾学术深度与工程落地价值的选题。本文围绕这套方案，从模拟数据生成、LSTM 模型训练，到基于 FastAPI 的预测与路径优化接口封装，做一次完整的实战拆解。文中代码均给出可运行的示例和说明，适合拿来改造成自己的毕设项目，也可以作为智能交通方向课程设计的参考。

1. 背景与核心概念

1.1 车辆路径优化问题是什么

车辆路径优化，在学术上通常对应 Vehicle Routing Problem（VRP），简单说就是“在给定起点、终点、路网结构和行驶约束的条件下，找出一条或多条成本最低的行驶路径”。这里说的成本可以是行驶距离、油耗、通行时间，也可以是三者加权后的综合代价。传统做法是把路网抽象成一张带权图，图中每个路口是一个节点，每段道路是一条带权边，然后用 Dijkstra、A*、Floyd 等经典图算法求解静态最短路径。

静态方案有一个隐含假设：每条边的权重在计算过程中是不变的。这个假设在道路交通平稳时基本成立，但一旦进入早晚高峰，或者某条路段突发拥堵，静态权重就会迅速失真。比如一条平时只需要 10 分钟的路线，晚高峰可能实际要开 25 分钟，此时走一条路程稍长但更通畅的路线反而更快。这正是动态路径优化要解决的问题。

1.2 为什么需要动态优化

动态优化和静态优化的最大区别在于：它会根据“未来可能发生的交通状态”来调整路径，而不是只依据“当前已有的历史平均值”。

要实现这种能力，通常需要两个环节配合。一是交通流预测，即基于历史交通数据和实时数据，预测未来 15 分钟、30 分钟甚至 1 小时内的路段拥堵程度；二是路径重规划，即把预测结果转换成路网中各条边的动态权重，再重新执行最短路径计算。预测环节决定了动态优化的上限，路径规划环节决定了响应速度。

深度学习在这个场景中的价值，主要体现在交通流预测上。传统时间序列方法（比如 ARIMA）对非线性、突发性交通变化拟合能力有限，而 LSTM、GRU 这类循环神经网络能够利用较长的历史窗口捕捉流量变化的时序规律，是目前毕设项目中性价比很高的选择。需要注意的是，预测只是前置模块，真正完成“路径输出”仍然需要图算法兜底，两者组合起来，才是一套完整的动态优化方案。

1.3 FastAPI 在系统中的角色

FastAPI 在这里扮演的是“模型服务化”的桥梁。

训练好的 LSTM 模型如果只停留在 Python 脚本阶段，就很难被前端页面、移动端 App 或者测试工具调用。FastAPI 基于 Python 类型注解自动生成 OpenAPI 文档，使用 Pydantic 做请求参数校验，天然适合把 PyTorch 模型包装成 REST 接口。它的同步def接口和异步async def接口都支持得很好，配合 Uvicorn 启动服务后，可以方便地暴露/predict、/optimize这类接口供外部调用。

在毕设答辩中，FastAPI 的另一个优势是：可以直接用浏览器打开http://localhost:8000/docs，看到接口文档和在线调试页面，演示效果非常直接，也方便评委现场测试。

2. 环境准备与版本说明

2.1 基础运行环境

本地开发建议使用 Linux 或 macOS，Windows 也可以，但要注意部分系统级依赖的安装方式可能不同。Python 环境建议使用 3.9 及以上版本，本文示例在 Python 3.10 环境下验证通过。如果你用的是 Python 3.11 或 3.12，注意检查 PyTorch 官方是否提供对应版本的预编译包。

核心依赖组件如下：

fastapi>=0.100.0 uvicorn[standard]>=0.23.0 pydantic>=2.0.0 numpy>=1.24.0 pandas>=2.0.0 torch>=2.0.0 scikit-learn>=1.2.0

这里没有把版本写死，因为不同电脑上 CUDA 版本、操作系统、Python 版本都会影响最终安装结果。如果你的机器没有 NVIDIA GPU，安装 CPU 版 PyTorch 即可，本文的 LSTM 模型规模很小，CPU 训练完全够用。

2.2 项目目录结构

为了让毕设代码结构清晰，建议一开始就按下面的方式组织目录：

traffic_route_optimization/ ├── app/ │ ├── __init__.py │ ├── main.py │ ├── schemas.py │ ├── core/ │ │ ├── __init__.py │ │ ├── config.py │ │ ├── model.py │ │ └── services.py │ └── router/ │ ├── __init__.py │ └── route.py ├── train/ │ ├── __init__.py │ ├── generate_data.py │ └── train_lstm.py ├── data/ ├── model/ ├── requirements.txt └── README.md

app目录负责 FastAPI 服务，train目录负责数据生成和模型训练，data存放模拟数据，model存放训练产物。这样的分层方式，在写论文和制作答辩 PPT 时也容易解释。

3. 核心原理拆解

3.1 动态路径优化的整体流程

完整流程可以拆成以下几步：

1. 采集或生成路网数据，包括路口节点、路段连接关系、行驶时间、历史交通流等。
2. 对每个路段建立时间序列样本，以过去若干时间步的交通流量和平均速度为特征，训练 LSTM 预测下一个时间步的流量。
3. 在实时请求到来时，把最近一段时间的观测数据输入模型，得到未来流量预测值。
4. 将预测流量转换为路段权重变化系数，常用做法是dynamic_weight = base_time * (1 + predicted_flow / capacity)，其中capacity是路段通行能力参考值。
5. 使用 Dijkstra 算法在更新权重后的路网上重新计算最短路径，并返回给调用方。

这套流程中，预测模块可以离线训练、在线推理，路径规划模块每次请求实时执行。两者解耦，方便单独替换模型或者优化算法。

3.2 LSTM 交通流预测模型设计

LSTM 的全称是 Long Short-Term Memory，长短期记忆网络。它解决了普通 RNN 在长序列上梯度消失的问题，有能力记住一个路段前 1 小时甚至前 3 小时的交通流变化趋势，从而对下一个时间点做出较合理的预测。

本文使用的模型输入结构是 [batch, sequence_length, features]。sequence_length表示历史窗口长度，设为 24，表示使用过去 24 个时间步（每步 15 分钟，即过去 6 小时）的数据做预测；features为 2，对应交通流量和平均速度两个特征。输出维度为 1，即预测下一个时间步的交通流量。

这里有一个训练容易忽略的点：输入特征必须做归一化，输出结果也需要反归一化。不使用归一化直接训练 LSTM，常常会导致 loss 数值非常大且训练不稳定，预测结果也会异常。

3.3 路径规划的动态权重策略

在获得预测流量后，路径规划需要把“流量”翻译成“行驶时间”。一个简单的工程化策略是比例惩罚：流量越大，通行时间越长。我们定义：

dynamic_weight = base_time * (1 + predicted_flow / 120)

这里的 120 是一个交通流量上限参考值，数值上可以理解成“当预测流量达到 120 时，该路段预计耗时翻倍”。这个公式虽然简单，但足以演示动态优化的核心逻辑。需要更强解释力时，也可以在论文中引用经典的 BPR 函数（Bureau of Public Roads function），其思路与上面的公式一致：在基准通行时间上叠加一个与流量比值相关的惩罚项。

4. 完整实战案例

下面从零开始搭建这套动态路径优化系统。为方便复现，数据部分使用模拟数据，代码在单机环境下可以直接运行。

4.1 生成模拟交通数据

真实的交通数据包含 GPS 轨迹、卡口流量、天气、事故等多源信息，取得完整数据集的成本较高。毕设演示阶段，可以先使用模拟数据验证整个流程，再用公开数据集替换。

在train/generate_data.py中写入以下代码：

# 文件路径：train/generate_data.py import random from datetime import datetime, timedelta import pandas as pd def generate_traffic_data(day_count=30, interval_minutes=15, road_count=10): """ 生成模拟交通数据。 参数说明: day_count : 模拟的天数 interval_minutes : 数据采样间隔（分钟） road_count : 道路编号数量 """ records = [] start_time = datetime(2024, 1, 1) for day in range(day_count): for minute in range(0, 24 * 60, interval_minutes): current_time = start_time + timedelta(days=day, minutes=minute) hour = current_time.hour # 早晚高峰时段基础流量更大 if 7 <= hour <= 9 or 17 <= hour <= 19: base_flow = random.randint(80, 120) else: base_flow = random.randint(20, 60) # 加入随机波动 flow = max(0, int(base_flow + random.gauss(0, 8))) speed = max(10.0, 80.0 - flow * 0.3 + random.gauss(0, 5)) for road_id in range(1, road_count + 1): records.append({ "timestamp": current_time, "road_id": road_id, "traffic_flow": max(0, flow + random.randint(-5, 5)), "avg_speed": round(min(90, speed + random.uniform(-3, 3)), 2), }) return pd.DataFrame(records) if __name__ == "__main__": traffic_df = generate_traffic_data() traffic_df.to_csv("data/traffic_data.csv", index=False) print(f"模拟数据生成完成: data/traffic_data.csv，共 {len(traffic_df)} 条记录")

运行脚本：

mkdir -p data model python train/generate_data.py

生成的数据中，timestamp是采样时间，road_id是路段编号，traffic_flow是观测流量，avg_speed是平均车速。数据量在 4 万条左右，足够训练一个简单的预测模型。

4.2 编写模型结构

为了让训练脚本和 FastAPI 服务共用同一个模型类，将模型结构单独拆到app/core/model.py：

# 文件路径：app/core/model.py import torch.nn as nn class TrafficPredictor(nn.Module): """ 用于交通流预测的 LSTM 模型。 input_size : 输入特征数量，本文为 2（交通流量、平均速度） hidden_size : LSTM 隐藏层维度 num_layers : LSTM 层数 output_size : 输出维度，本文为 1（预测交通流量） """ def __init__(self, input_size=2, hidden_size=64, num_layers=2, output_size=1): super().__init__() self.lstm = nn.LSTM(input_size, hidden_size, num_layers, batch_first=True) self.fc = nn.Linear(hidden_size, output_size) def forward(self, x): out, _ = self.lstm(x) # 取最后一个时间步的隐层输出 return self.fc(out[:, -1, :])

模型的输出的是下个时间步的流量值，没有添加激活函数，因为它做的是回归任务。

4.3 编写训练脚本

在train/train_lstm.py中完成数据加载、数据集划分、模型训练与模型保存：

# 文件路径：train/train_lstm.py import sys from pathlib import Path import numpy as np import pandas as pd import torch import torch.nn as nn from sklearn.preprocessing import MinMaxScaler from torch.utils.data import DataLoader, TensorDataset # 将项目根目录加入 Python 路径，方便导入 app 下的模块 sys.path.append(str(Path(__file__).resolve().parent.parent)) from app.core.model import TrafficPredictor SEQ_LEN = 24 EPOCHS = 30 BATCH_SIZE = 32 LEARNING_RATE = 1e-3 MODEL_SAVE_PATH = "model/traffic_predictor.pth" SCALER_MIN_PATH = "model/scaler_min.npy" SCALER_SCALE_PATH = "model/scaler_scale.npy" def create_sequences(data, seq_len): 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), ) def main(): df = pd.read_csv("data/traffic_data.csv", parse_dates=["timestamp"]) road_df = df[df["road_id"] == 1].sort_values("timestamp") features = road_df[["traffic_flow", "avg_speed"]].values # 归一化 scaler = MinMaxScaler() scaled = scaler.fit_transform(features) X, y = create_sequences(scaled, SEQ_LEN) # 只预测 traffic_flow，所以取 y 的第二列，也就是第 0 列 y = y[:, :1] X_tensor = torch.tensor(X, dtype=torch.float32) y_tensor = torch.tensor(y, dtype=torch.float32) split = int(len(X_tensor) * 0.8) train_dataset = TensorDataset(X_tensor[:split], y_tensor[:split]) val_dataset = TensorDataset(X_tensor[split:], y_tensor[split:]) train_loader = DataLoader(train_dataset, batch_size=BATCH_SIZE, shuffle=True) val_loader = DataLoader(val_dataset, batch_size=BATCH_SIZE, shuffle=False) model = TrafficPredictor(input_size=2) loss_fn = nn.MSELoss() optimizer = torch.optim.Adam(model.parameters(), lr=LEARNING_RATE) for epoch in range(EPOCHS): model.train() total_loss = 0.0 for batch_x, batch_y in train_loader: optimizer.zero_grad() pred = model(batch_x) loss = loss_fn(pred, batch_y) loss.backward() optimizer.step() total_loss += loss.item() * len(batch_x) train_loss = total_loss / len(train_dataset) model.eval() val_loss = 0.0 with torch.no_grad(): for batch_x, batch_y in val_loader: pred = model(batch_x) loss = loss_fn(pred, batch_y) val_loss += loss.item() * len(batch_x) val_loss = val_loss / len(val_dataset) if (epoch + 1) % 5 == 0: print(f"Epoch {epoch + 1}/{EPOCHS}, Train Loss={train_loss:.6f}, Val Loss={val_loss:.6f}") # 保存模型参数 torch.save(model.state_dict(), MODEL_SAVE_PATH) # 保存归一化参数，供 API 推理时使用 np.save(SCALER_MIN_PATH, scaler.data_min_) np.save(SCALER_SCALE_PATH, scaler.data_max_ - scaler.data_min_) print("模型训练完成，模型参数与归一化参数已保存到 model/ 目录") if __name__ == "__main__": main()

运行训练脚本：

python train/train_lstm.py

正常情况下，可以看到训练 Loss 逐渐下降。因为使用的是模拟数据，最终 Loss 不会特别小，属于正常现象；真实数据训练时，可以通过增加EPOCHS、调整hidden_size或改用Transformer提升精度。

4.4 使用 FastAPI 封装预测服务

接下来搭建 FastAPI 服务。先写全局配置app/core/config.py：

# 文件路径：app/core/config.py import os from pathlib import Path BASE_DIR = Path(__file__).resolve().parent.parent.parent SEQ_LEN = 24 MODEL_PATH = os.getenv("MODEL_PATH", str(BASE_DIR / "model" / "traffic_predictor.pth")) SCALER_MIN_PATH = os.getenv("SCALER_MIN_PATH", str(BASE_DIR / "model" / "scaler_min.npy")) SCALER_SCALE_PATH = os.getenv("SCALER_SCALE_PATH", str(BASE_DIR / "model" / "scaler_scale.npy"))

写 Pydantic 请求模型app/schemas.py：

# 文件路径：app/schemas.py from typing import List from pydantic import BaseModel class TrafficPredictRequest(BaseModel): road_id: int history_flow: List[float] history_speed: List[float] class EdgeCondition(BaseModel): u: int v: int base_time: float # 基准行驶时间（分钟） predicted_flow: float # 预测流量 class RouteOptimizeRequest(BaseModel): start: int destination: int edges: List[EdgeCondition]

在app/core/services.py中实现模型加载、预测和 Dijkstra 算法：

# 文件路径：app/core/services.py import heapq from typing import Dict, List, Tuple import numpy as np import torch from app.core import config from app.core.model import TrafficPredictor _model = None _scaler_min = None _scaler_scale = None def _load_model(): global _model, _scaler_min, _scaler_scale if _model is None: _model = TrafficPredictor(input_size=2) state_dict = torch.load(config.MODEL_PATH, map_location="cpu") _model.load_state_dict(state_dict) _model.eval() _scaler_min = np.load(config.SCALER_MIN_PATH) _scaler_scale = np.load(config.SCALER_SCALE_PATH) def predict_traffic_flow(history_flow: List[float], history_speed: List[float]) -> float: """ 基于历史流量与历史速度预测下一个时间步的交通流量。 输入长度需要与训练时的 SEQ_LEN 保持一致。 """ if len(history_flow) != len(history_speed): raise ValueError("history_flow 与 history_speed 长度必须一致") _load_model() flow_arr = np.array(history_flow, dtype=np.float32).reshape(-1, 1) speed_arr = np.array(history_speed, dtype=np.float32).reshape(-1, 1) # 归一化 scaled_flow = (flow_arr - _scaler_min[0]) / (_scaler_scale[0] + 1e-8) scaled_speed = (speed_arr - _scaler_min[1]) / (_scaler_scale[1] + 1e-8) features = np.concatenate([scaled_flow, scaled_speed], axis=1) # 如果不足 SEQ_LEN，用首条数据重复补齐，方便日常测试 if len(features) < config.SEQ_LEN: pad_len = config.SEQ_LEN - len(features) pad_data = np.repeat(features[:1], pad_len, axis=0) features = np.concatenate([pad_data, features], axis=0) else: features = features[-config.SEQ_LEN:] input_tensor = torch.tensor(features, dtype=torch.float32).unsqueeze(0) with torch.no_grad(): output = _model(input_tensor).item() # 反归一化 pred_flow = output * (_scaler_scale[0] + 1e-8) + _scaler_min[0] return max(0.0, pred_flow) def dijkstra(graph: Dict[int, List[Tuple[int, float]]], start: int, end: int): """ 基于最小堆实现的 Dijkstra 算法。 返回 (路径节点列表, 总权重)。 """ pq = [(0.0, start, [start])] dist = {start: 0.0} visited = set() while pq: d, node, path = heapq.heappop(pq) if node in visited: continue visited.add(node) if node == end: return path, d for neighbor, weight in graph.get(node, []): new_d = d + weight if new_d < dist.get(neighbor, float("inf")): dist[neighbor] = new_d heapq.heappush(pq, (new_d, neighbor, path + [neighbor])) return [], float("inf")

在app/router/route.py中定义接口路由：

# 文件路径：app/router/route.py from fastapi import APIRouter, HTTPException from app.core import services from app.schemas import RouteOptimizeRequest, TrafficPredictRequest router = APIRouter() @router.post("/traffic/predict") def traffic_predict(req: TrafficPredictRequest): """ 交通流预测接口。 输入最近一段时间的流量与速度，预测下一个时间步流量。 """ try: pred = services.predict_traffic_flow(req.history_flow, req.history_speed) except FileNotFoundError: raise HTTPException(status_code=500, detail="模型文件不存在，请先运行 train/train_lstm.py") except Exception as e: raise HTTPException(status_code=500, detail=f"预测失败: {str(e)}") return { "road_id": req.road_id, "predicted_flow": round(pred, 2), } @router.post("/route/optimize") def route_optimize(req: RouteOptimizeRequest): """ 动态路径优化接口。 根据预测流量动态调整各边权重，然后求解最短路径。 """ graph = {} # 动态权重策略：流量越大，耗时惩罚越大 for edge in req.edges: dynamic_weight = edge.base_time * (1 + edge.predicted_flow / 120.0) graph.setdefault(edge.u, []).append((edge.v, dynamic_weight)) graph.setdefault(edge.v, []).append((edge.u, dynamic_weight)) path, total_time = services.dijkstra(graph, req.start, req.destination) if not path: raise HTTPException(status_code=404, detail="未找到可用路径") return { "path": path, "total_time": round(total_time, 2), "strategy": "dynamic-flow-based", }

最后是 FastAPI 入口app/main.py：

# 文件路径：app/main.py from fastapi import FastAPI from app.router.route import router app = FastAPI( title="智能交通车辆路径动态优化服务", description="基于深度学习的交通流预测与路径动态优化 API，适用于智能交通方向的毕业设计演示。", version="1.0.0", ) app.include_router(router, prefix="/api/v1") @app.get("/health") def health_check(): return {"status": "ok"}

4.5 启动服务与接口测试

安装依赖后，在项目根目录启动服务：

uvicorn app.main:app --host 0.0.0.0 --port 8000 --reload

启动成功后，浏览器访问http://localhost:8000/docs即可看到 Swagger 文档页面。

测试预测接口：

curl -X POST "http://localhost:8000/api/v1/traffic/predict" \ -H "Content-Type: application/json" \ -d '{ "road_id": 1, "history_flow": [20, 25, 30, 35, 40, 45, 50, 60, 70, 80, 90, 100, 85, 75, 65, 55, 50, 45, 40, 35, 30, 28, 25, 22], "history_speed": [75, 74, 72, 70, 68, 65, 62, 58, 50, 45, 38, 30, 35, 42, 50, 56, 60, 63, 66, 68, 70, 72, 74, 76] }'

预期接口返回一个接近实测流量范围的数值，例如：

{ "road_id": 1, "predicted_flow": 23.45 }

测试动态路径优化接口，这里构建一个 6 个节点的路网示例：

curl -X POST "http://localhost:8000/api/v1/route/optimize" \ -H "Content-Type: application/json" \ -d '{ "start": 1, "destination": 6, "edges": [ {"u": 1, "v": 2, "base_time": 10, "predicted_flow": 30}, {"u": 2, "v": 3, "base_time": 8, "predicted_flow": 80}, {"u": 1, "v": 3, "base_time": 15, "predicted_flow": 40}, {"u": 3, "v": 4, "base_time": 6, "predicted_flow": 60}, {"u": 4, "v": 6, "base_time": 10, "predicted_flow": 20}, {"u": 2, "v": 5, "base_time": 12, "predicted_flow": 45}, {"u": 5, "v": 6, "base_time": 8, "predicted_flow": 90} ] }'

接口会返回一条综合考虑流量惩罚后的路径。如果把某条边的predicted_flow调大，返回路径很可能会改变，这正是动态优化的价值。

5. 常见问题与排查思路

在实际复现这套系统时，容易遇到下面这些问题，汇总成表格方便对照排查。

排查思路可以参考下面这个顺序：

1. 先在docs页面看接口返回的状态码和错误信息。
2. 检查model/目录下是否存在traffic_predictor.pth、scaler_min.npy、scaler_scale.npy三个文件。
3. 检查请求体中的数组长度是否与SEQ_LEN一致。
4. 打印模型输出的原始值和反归一化后的值，判断问题出现在推理环节还是后处理环节。

6. 最佳实践与工程建议

6.1 模型训练与推理的版本管理

在毕设项目中，模型文件、训练脚本、API 代码经常同时修改，最容易出现“训练脚本能跑，接口加载报错”的问题。建议给模型文件命名时加入时间戳或训练轮次，比如traffic_predictor_epoch30.pth。如果在 API 中启用了版本管理，可以同时保留多个模型文件，并在配置中切换当前生效模型。

6.2 请求输入校验与异常兜底

FastAPI 虽然通过 Pydantic 做了参数类型校验，但业务层面的校验仍然需要自己处理。例如history_flow传入空数组，或者history_speed与history_flow长度不一致，都应当在服务内部主动抛出明确错误，而不是让模型层报一堆难懂的维度错误。

6.3 数据合规与最小权限

如果后续接入真实城市路网数据或网约车 GPS 数据，务必确认数据来源已经获得合法授权，并对用户隐私字段（车牌、手机号、精确 GPS 轨迹）做脱敏处理。毕设项目使用合成数据和公开数据最稳妥，不要直接爬取未授权数据。

6.4 性能优化方向

当路网规模变大后，每次请求都执行一次全量 Dijkstra 可能会成为瓶颈。可以考虑这样几个方向：

• 对多段常用路径做缓存，相同起终点在一定时间窗口内直接返回缓存结果。
• 引入 Redis 缓存交通流预测结果，相同路段短时间内不做重复推理。
• 将路网图改为邻接矩阵或使用更高效的堆优化 Dijkstra 实现。
• 如果业务量继续增长，可考虑将路径规划部分迁移到 C++ 或 Go 微服务中，Python 服务只负责模型推理。

6.5 日志与接口监控

建议在关键接口中记录请求耗时、输入数据长度、模型预测结果等关键指标。尤其在答辩演示时，如果现场出现异常，完整的日志能快速说明问题出在数据侧还是模型侧。可以为/api/v1/traffic/predict接口增加结构化日志：

import logging logger = logging.getLogger("traffic-api") logger.info("predict request, road_id=%s, history_len=%s", req.road_id, len(req.history_flow))

不要把所有逻辑堆在路由函数里，预测服务、路径优化服务、日志组件可以分层实现，既方便测试也方便维护。

7. 总结与学习路线

本文围绕智能交通中的车辆路径动态优化，完成了一套从模拟数据生成、LSTM 交通流预测模型训练，到 FastAPI 接口封装与 Dijkstra 动态路径计算的完整方案。核心收获有四点：第一，理解了动态路径优化与传统静态路径规划的差异；第二，掌握了 LSTM 模型在时间序列预测中的基本使用方法，包括归一化、窗口构造、训练与反归一化；第三，学会了用 FastAPI 将 PyTorch 模型封装成可调用的 REST 接口；第四，实践了如何将预测流量转化为动态边的权重，并结合图算法完成路径重规划。

后续如果想继续深入，可以从三个方向拓展。一是模型层面，将 LSTM 替换为 GRU、Transformer 或结合注意力机制，对比预测效果；二是算法层面，引入强化学习方法，让路径规划具备更强的自适应性；三是工程层面，把服务打包成 Docker 镜像，接入前端地图可视化，并部署到服务器上提供持续服务。

在实际完成毕设项目的过程中，有一个容易被忽略但性价比很高的做法：先把模拟数据跑通全流程，再逐步替换成真实数据集。这样做的好处是，整个系统框架一旦稳定，后续的替换成本就只集中在数据预处理和模型调优上。在答辩演示时，建议准备一组对比数据，分别展示静态规划路径和动态优化路径在模拟拥堵场景下的差异，这比单纯介绍模型结构更能让评委直观理解系统的价值。

如果这篇文章对你有帮助，可以收藏作为参考。搭建过程中如果遇到具体报错，欢迎在评论区留言交流，我会根据实际经验帮你分析问题方向。