从Claw-Eval到Claw-Eval-Live:Agent评测“下半场”，为什么需要一个"活的" Benchmark？
2026-05-24 3333332
2026-05-24 0
平时我们出门坐公交，打开地图输入起点和终点，几秒钟就能跳出好几条路线，有的最快、有的少换乘、有的走路少。一直都很好奇，这种路径规划的实现方式到底是怎么实现的，是什么算法支撑的，总在琢磨，但最后又在不解中慢慢就遗忘了，往往就是这种日常应用的功能看着很普通，适应了之后好像理所应当就该这样，但背后其实是一整套非常复杂的技术在支撑。从最早只能按固定线路查询，到现在能自动避开拥堵、理解我们“不想走路”、“少换乘” 的要求，公交路线规划早就不是简单算个最短距离那么简单了。
尤其是近几年大模型快速普及，传统的算法又迎来了一次全新升级。以前的系统只能处理死板的数据和规则，现在却能听懂人话、看懂实时路况、还能根据不同人的习惯给出个性化方案。对城市交通管理者来说，智能规划能优化线路、提高运力；对普通用户来说，就是出行更省心、更快、更舒服。今天我们一起好好琢磨，从最基础的原理讲起，一步步带的搞懂：公交车站点线路智能规划到底是怎么实现的，大模型在里面又起到了哪些关键作用，哪怕我们之前没接触过算法和模型，也能通俗的看明白。
公交站点线路的智能规划，本质是在给定公交站点网络中，包括站点、线路、站点间通行时间和距离、发车频率等信息，以起始站和终点站为输入，通过算法或模型输出最优以及次优的公交出行方案。这里的最优可定义为耗时最短、换乘次数最少、步行距离最短、费用最低等单一目标，也可以是多目标加权的综合最优。
从应用场景来看，它是城市智慧交通的核心模块之一，常见于公交 APP、城市交通调度系统、出行服务平台等。而大模型的融入，让这一过程从基于固定规则或传统算法升级为“数据驱动 + 语义理解 + 动态决策”，既能处理结构化的站点数据，也能理解非结构化的用户需求，如“我想避开早高峰拥堵的站点”、“优先走有空调的公交线路”。
为了强化快速理解，我们先梳理核心术语：
所有公交路线规划的底层逻辑都基于图论，我们先从最基础的 “图” 开始理解：
1.1 公交网络的图建模
假设我们有如下简化的公交网络：
我们可以把这个网络建模为 “无向图”，忽略行驶方向，仅关注连通性，用表格表示节点和边的权重（耗时）：
起点 | 终点 | 权重（耗时 / 分钟） | 类型 |
|---|---|---|---|
A | B | 5 | 公交 |
B | C | 5 | 公交 |
C | D | 8 | 公交 |
A | C | 20 | 步行 |
在代码中，我们可以用networkx库来构建这个图：
代码语言：pythonimport networkx as nx
import matplotlib.pyplot as plt
# 1. 创建无向图
G = nx.Graph()
# 2. 添加节点（公交站点）
nodes = ["A", "B", "C", "D"]
G.add_nodes_from(nodes)
# 3. 添加边（站点间的连接），并设置权重（耗时）
edges = [
("A", "B", {"weight": 5, "type": "公交"}),
("B", "C", {"weight": 5, "type": "公交"}),
("C", "D", {"weight": 8, "type": "公交"}),
("A", "C", {"weight": 20, "type": "步行"})
]
G.add_edges_from(edges)
# 4. 可视化图（输出图片）
plt.rcParams["font.sans-serif"] = ["SimHei"] # 解决中文显示
pos = nx.spring_layout(G, seed=42) # 固定布局
nx.draw(G, pos, with_labels=True, node_size=2000, node_color="lightblue", font_size=12)
# 添加边的权重标签
edge_labels = {(u, v): f"{d['weight']}分钟({d['type']})" for u, v, d in G.edges(data=True)}
nx.draw_networkx_edge_labels(G, pos, edge_labels=edge_labels, font_size=10)
plt.title("简化公交网络拓扑图")
plt.savefig("bus_network_graph.png", dpi=300, bbox_inches="tight")
plt.show()代码说明：
结果图示：
考虑公交行驶方向，可用带箭头的有向图展示：
Dijkstra 算法是公交规划中最常用的基础算法，核心逻辑是“从起点出发，逐步找到到每个节点的最短路径”，适合权重为非负数的场景，特别是公交耗时、距离均为正数。
我们用代码实现 Dijkstra 算法，求解从 A 到 D 的最短耗时路径：
代码语言：pythondef dijkstra_shortest_path(graph, start, end):
"""
实现Dijkstra算法，返回从起点到终点的最短路径和总权重
:param graph: networkx构建的图
:param start: 起始节点
:param end: 终止节点
:return: 最短路径列表、总权重
"""
# 初始化：距离字典（起点到各节点的距离），前驱节点字典
distance = {node: float("inf") for node in graph.nodes}
distance[start] = 0 # 起点到自身距离为0
predecessor = {node: None for node in graph.nodes}
unvisited = set(graph.nodes) # 未访问节点集合
print("=" * 60)
print("Dijkstra算法计算过程")
print("=" * 60)
print()
iteration = 0
while unvisited:
iteration += 1
# 选择当前距离最小的未访问节点
current_node = min(unvisited, key=lambda node: distance[node])
unvisited.remove(current_node)
print(f"第{iteration}步: 选中节点 {current_node} (距离: {distance[current_node]})")
# 若当前节点是终点，提前终止
if current_node == end:
print(f" 已到达终点，算法完成")
break
# 遍历当前节点的邻居
for neighbor in graph.neighbors(current_node):
if neighbor in unvisited:
edge_weight = graph[current_node][neighbor]["weight"]
edge_type = graph[current_node][neighbor]["type"]
new_distance = distance[current_node] + edge_weight
# 更新距离和前驱节点
if new_distance < distance[neighbor]:
print(f" 更新 {neighbor}: {distance[current_node]} + {edge_weight} = {new_distance} (原距离{distance[neighbor]})")
distance[neighbor] = new_distance
predecessor[neighbor] = current_node
print()
# 回溯构建最短路径
path = []
current = end
while current is not None:
path.append(current)
current = predecessor[current]
path.reverse() # 反转得到从起点到终点的路径
# 若路径只有终点（无连通路径），返回空
if path[0] != start:
return [], float("inf")
return path, distance[end]
# 调用函数求解A到D的最短路径
shortest_path, total_time = dijkstra_shortest_path(G, "A", "D")
print(f"从A到D的最短耗时路径：{shortest_path}")
print(f"总耗时：{total_time}分钟")算法说明：
输出结果：
============================================================ Dijkstra算法计算过程 ============================================================ 第1步: 选中节点 A (距离: 0) 更新 B: 0 + 5 = 5 (原距离inf) 更新 C: 0 + 20 = 20 (原距离inf) 第2步: 选中节点 B (距离: 5) 更新 C: 5 + 5 = 10 (原距离20) 第3步: 选中节点 C (距离: 10) 更新 D: 10 + 8 = 18 (原距离inf) 第4步: 选中节点 D (距离: 18) 已到达终点，算法完成 从A到D的最短耗时路径：['A', 'B', 'C', 'D'] 总耗时：18分钟
正常情况下耗时18分钟，如果公交拥堵，考虑备选路线：
实际公交规划中，静态的基础耗时无法反映真实情况，需要融合动态数据，如拥堵导致耗时增加、公交晚点。核心原理是：
示例代码（模拟动态拥堵调整）：
代码语言：python# 模拟获取实时拥堵数据（实际中可通过API获取）
congestion_factor = {
("A", "B"): 1.5, # A→B拥堵，耗时×1.5
("B", "C"): 1.2, # B→C轻微拥堵，耗时×1.2
("C", "D"): 1.0, # C→D无拥堵
("A", "C"): 1.0 # 步行无拥堵
}
# 动态更新图的边权重
for (u, v), factor in congestion_factor.items():
original_weight = G[u][v]["weight"]
G[u][v]["weight"] = original_weight * factor
# 重新计算最短路径
updated_path, updated_time = dijkstra_shortest_path(G, "A", "D")
print(f"拥堵后从A到D的最短路径：{updated_path}")
print(f"拥堵后总耗时：{updated_time}分钟")输出结果：
============================================================ Dijkstra算法计算过程 ============================================================ 第1步: 选中节点 A (距离: 0) 更新 B: 0 + 7.5 = 7.5 (原距离inf) 更新 C: 0 + 20.0 = 20.0 (原距离inf) 第2步: 选中节点 B (距离: 7.5) 更新 C: 7.5 + 6.0 = 13.5 (原距离20.0) 第3步: 选中节点 C (距离: 13.5) 更新 D: 13.5 + 8.0 = 21.5 (原距离inf) 第4步: 选中节点 D (距离: 21.5) 已到达终点，算法完成 拥堵后从A到D的最短路径：['A', 'B', 'C', 'D'] 拥堵后总耗时：21.5分钟
大模型的核心价值：从规则驱动到智能驱动，传统公交规划的痛点是刚性，所有决策依赖预设规则，无法处理复杂、个性化、非标准化的需求。而大模型的融入，解决了以下核心问题：
用户实际使用时，不会输入“起点 A + 终点 D”，而是说“我从 XX 小区（A）到 XX 医院（D），下午 5 点下班高峰出发，尽量少换乘，不想走超过 5 分钟的路”。大模型能将这种自然语言需求转化为规划算法可识别的结构化参数：
公交规划的最优是多维度的，如耗时、换乘、步行，不同用户的偏好不同：
大模型可通过学习用户历史行为，或通过对话交互，自动调整多目标的权重，如给步行距离设置更高的权重惩罚，生成个性化路线。
临时封站、线路改道、极端天气等异常场景，超出了传统规则的覆盖范围。大模型可通过知识推理给出替代方案：
传统规划仅输出“站点列表”，大模型可将结果转化为通俗易懂的自然语言：
流程说明：
1. 用户输入自然语言需求： 用户用日常语言提出出行需求，例如“从西湖到灵隐寺，想要少走路，优先地铁”。
2. 大模型语义解析： 大模型理解用户意图，从自然语言中提取关键信息，如起点、终点、时间、偏好（少步行、优先地铁、避开拥堵等）。
3. 结构化参数输出： 将解析结果转化为程序可处理的标准化格式，例如：{start: "西湖", end: "灵隐寺", constraints: ["少步行"], preferences: ["优先地铁"]}。
4. 融合静态+动态公交数据： 整合基础公交线路数据（站点、票价、运营时间）和实时动态数据（拥堵情况、到站预测、临时管制）。
5. 构建/更新公交网络图： 将公交线路抽象为图结构：站点是节点，公交线路是边，并根据实时数据动态更新边的权重（时间、拥挤度等）。
6. 传统最短路径算法求解候选路径： 使用Dijkstra或A*算法在公交网络图上搜索出若干条候选路线，每条路线包含换乘方案、预计时间、步行距离等。
7. 大模型多目标评估+个性化排序： 大模型结合用户偏好（少步行、少换乘、低票价等）对候选路线进行综合评分，并重新排序，选出最适合用户的路线。
8. 大模型生成自然语言路线说明： 将排序后的路线转化为清晰易懂的文字说明，包含起点、换乘点、步行指引、预计耗时等细节。
9. 输出最终路线方案： 将完整的路线说明返回给用户，支持文本展示、语音播报或地图可视化。
使用算法结合大模型，根据用户需求"从A_小区到D_医院，下午5点高峰时段出发，换乘次数不要超过1次，步行时间尽量少，优先耗时最短的路线"，实现最优路线规划；
代码语言：pythonimport os
import networkx as nx
import matplotlib.pyplot as plt
from openai import OpenAI
from dotenv import load_dotenv
import json
# 使用腾讯混元大模型
api_key = os.getenv('TENCENT_API_KEY', 'sk-bWlJPKjBrSF********8Ze')
client = OpenAI(
api_key=api_key,
base_url="https://api.hunyuan.cloud.tencent.com/v1",
)
# ===================== 第一步：构建基础公交网络 =====================
def build_bus_network():
"""构建包含更多站点的公交网络（贴近真实场景）"""
G = nx.Graph()
# 站点列表（含小区、商场、地铁、医院、学校）
nodes = ["A_小区", "B_商场", "C_地铁1号线", "D_医院", "E_学校", "F_公园", "G_地铁站2号线"]
G.add_nodes_from(nodes)
# 边列表：(起点, 终点, 权重(耗时/分钟), 类型, 线路号)
edges = [
("A_小区", "B_商场", {"weight": 5, "type": "公交", "line": "1路"}),
("B_商场", "C_地铁1号线", {"weight": 5, "type": "公交", "line": "1路"}),
("C_地铁1号线", "D_医院", {"weight": 8, "type": "公交", "line": "2路"}),
("A_小区", "C_地铁1号线", {"weight": 20, "type": "步行"}),
("C_地铁1号线", "E_学校", {"weight": 10, "type": "公交", "line": "3路"}),
("E_学校", "D_医院", {"weight": 15, "type": "公交", "line": "4路"}),
("B_商场", "F_公园", {"weight": 7, "type": "公交", "line": "5路"}),
("F_公园", "G_地铁站2号线", {"weight": 6, "type": "公交", "line": "5路"}),
("G_地铁站2号线", "D_医院", {"weight": 12, "type": "地铁", "line": "2号线"})
]
G.add_edges_from(edges)
return G
# ===================== 第二步：大模型解析自然语言需求 =====================
def parse_user_request_with_llm(user_request):
"""
使用大模型解析用户自然语言需求，提取结构化参数
:param user_request: 用户输入的自然语言需求
:return: 结构化参数字典（起点、终点、约束条件、偏好）
"""
prompt = f"""
请你作为公交路线规划助手，解析用户的自然语言需求，提取以下结构化信息：
1. 起点（精确提取站点名称，如"A_小区"、"B_商场"、"C_地铁1号线"、"D_医院"、"E_学校"、"F_公园"、"G_地铁站2号线"）；
2. 终点（精确提取站点名称，如"A_小区"、"B_商场"、"C_地铁1号线"、"D_医院"、"E_学校"、"F_公园"、"G_地铁站2号线"）；
3. 约束条件（如换乘次数≤1、步行耗时≤5分钟、避免拥堵路段）；
4. 用户偏好（如优先少换乘、优先耗时最短、优先步行少、优先地铁）。
用户需求：{user_request}
输出格式要求：
以JSON格式输出，键为"start_point", "end_point", "constraints", "preferences"，
constraints和preferences为列表形式，若无则为空列表。
重要提示：
- 必须从用户输入中准确提取起点和终点的完整站点名称
- 起点和终点必须是下列站点之一：A_小区、B_商场、C_地铁1号线、D_医院、E_学校、F_公园、G_地铁站2号线
- 严禁编造站点名称或使用省略号
示例输出：
{{
"start_point": "A_小区",
"end_point": "D_医院",
"constraints": ["换乘次数≤1", "步行耗时≤5分钟"],
"preferences": ["优先耗时最短"]
}}
"""
# 调用腾讯混元API
response = client.chat.completions.create(
model="hunyuan-lite",
messages=[{"role": "user", "content": prompt}],
temperature=0.1 # 低随机性，保证解析结果稳定
)
# 提取并返回JSON结果
try:
content = response.choices[0].message.content.strip()
# 清理可能存在的markdown代码块标记
if content.startswith("```json"):
content = content[7:]
if content.startswith("```"):
content = content[3:]
if content.endswith("```"):
content = content[:-3]
content = content.strip()
result = json.loads(content)
# 验证站点名称是否在图节点中
valid_nodes = ["A_小区", "B_商场", "C_地铁1号线", "D_医院", "E_学校", "F_公园", "G_地铁站2号线"]
if result.get("start_point") not in valid_nodes or result.get("end_point") not in valid_nodes:
# 如果解析的站点名称无效，返回默认值
print(f"警告：解析的站点名称无效，start={result.get('start_point')}, end={result.get('end_point')}")
return {
"start_point": "A_小区",
"end_point": "D_医院",
"constraints": result.get("constraints", []),
"preferences": result.get("preferences", [])
}
return result
except json.JSONDecodeError as e:
# 解析失败时返回默认值
print(f"JSON解析失败: {e}, 返回内容: {content}")
return {
"start_point": "A_小区",
"end_point": "D_医院",
"constraints": ["换乘次数≤1"],
"preferences": ["优先耗时最短"]
}
# ===================== 第三步：Dijkstra算法求解候选路径 =====================
def dijkstra_with_constraints(graph, start, end, constraints=None, preferences=None):
"""
带约束和偏好的最短路径求解
:param graph: 公交网络图
:param start: 起点
:param end: 终点
:param constraints: 约束条件列表
:param preferences: 偏好列表
:return: 最优路径、总耗时、路径详情（含线路、类型）
"""
if constraints is None:
constraints = []
if preferences is None:
preferences = []
# 1. 先获取所有可能的路径（简化版：仅获取前3条最短路径）
all_paths = list(nx.shortest_simple_paths(graph, start, end, weight="weight"))[:3]
path_details = []
# 2. 为每条路径计算详细信息（总耗时、换乘次数、步行耗时）
for path in all_paths:
total_time = 0
transfer_count = 0
walk_time = 0
last_line = None
line_details = []
for i in range(len(path)-1):
u = path[i]
v = path[i+1]
edge_data = graph[u][v]
time = edge_data["weight"]
line = edge_data.get("line", "步行")
type_ = edge_data["type"]
total_time += time
if type_ == "步行":
walk_time += time
else:
if line != last_line and last_line is not None:
transfer_count += 1
last_line = line
line_details.append(f"{line}({type_}): {u}→{v} ({time}分钟)")
# 3. 构建路径详情字典
path_info = {
"path": path,
"total_time": total_time,
"transfer_count": transfer_count,
"walk_time": walk_time,
"line_details": line_details
}
path_details.append(path_info)
# 4. 根据约束条件过滤路径
filtered_paths = []
for info in path_details:
valid = True
# 处理换乘次数约束
for constraint in constraints:
if "换乘次数≤" in constraint:
max_transfer = int(constraint.split("≤")[1])
if info["transfer_count"] > max_transfer:
valid = False
if "步行耗时≤" in constraint:
max_walk = int(constraint.split("≤")[1])
if info["walk_time"] > max_walk:
valid = False
if valid:
filtered_paths.append(info)
# 5. 根据偏好排序
if not filtered_paths:
filtered_paths = path_details # 无符合约束的路径，返回所有
if "优先耗时最短" in preferences:
filtered_paths.sort(key=lambda x: x["total_time"])
elif "优先少换乘" in preferences:
filtered_paths.sort(key=lambda x: x["transfer_count"])
elif "优先步行少" in preferences:
filtered_paths.sort(key=lambda x: x["walk_time"])
# 返回最优路径（第一条）
if filtered_paths:
best_path = filtered_paths[0]
return best_path["path"], best_path["total_time"], best_path["line_details"]
else:
return [], 0, []
# ===================== 第四步：大模型生成自然语言路线说明 =====================
def generate_route_description_with_llm(path, total_time, line_details, user_preferences):
"""
使用大模型将路径信息转化为自然语言说明
:param path: 最优路径列表
:param total_time: 总耗时
:param line_details: 线路详情
:param user_preferences: 用户偏好
:return: 自然语言路线说明
"""
prompt = f"""
请你作为公交路线规划助手，根据以下信息生成通俗易懂的路线说明：
1. 最优路径：{path}
2. 总耗时：{total_time}分钟
3. 线路详情：{line_details}
4. 用户偏好：{user_preferences}
要求：
- 语言简洁明了，步骤清晰；
- 突出用户偏好（如优先少换乘）；
- 给出温馨提示（如换乘站点、步行注意事项）；
- 避免使用专业术语，适合普通用户理解。
"""
response = client.chat.completions.create(
model="hunyuan-lite",
messages=[{"role": "user", "content": prompt}],
temperature=0.7 # 适度随机性，让语言更自然
)
return response.choices[0].message.content
# ===================== 主函数：整合所有流程 =====================
def main():
# 1. 构建公交网络
bus_graph = build_bus_network()
# 2. 可视化公交网络（保存图片）
plt.rcParams["font.sans-serif"] = ["SimHei"]
pos = nx.spring_layout(bus_graph, seed=42)
nx.draw(bus_graph, pos, with_labels=True, node_size=1500, node_color="lightgreen", font_size=8)
edge_labels = {(u, v): f"{d.get('line', '步行')}n{d['weight']}分钟" for u, v, d in bus_graph.edges(data=True)}
nx.draw_networkx_edge_labels(bus_graph, pos, edge_labels=edge_labels, font_size=6)
plt.title("真实场景公交网络拓扑图")
plt.savefig("real_bus_network.png", dpi=300, bbox_inches="tight")
plt.show()
# 3. 用户输入自然语言需求
user_request = "我从A_小区到D_医院，下午5点高峰时段出发，换乘次数不要超过1次，步行时间尽量少，优先耗时最短的路线"
print(f"用户需求：{user_request}n")
# 4. 大模型解析需求
parsed_info = parse_user_request_with_llm(user_request)
print(f"大模型解析的结构化参数：{parsed_info}n")
# 5. 求解最优路径
start = parsed_info["start_point"]
end = parsed_info["end_point"]
constraints = parsed_info["constraints"]
preferences = parsed_info["preferences"]
best_path, total_time, line_details = dijkstra_with_constraints(
bus_graph, start, end, constraints, preferences
)
print(f"算法求解的最优路径：{best_path}")
print(f"总耗时：{total_time}分钟")
print(f"线路详情：{line_details}n")
# 6. 大模型生成自然语言说明
route_description = generate_route_description_with_llm(best_path, total_time, line_details, preferences)
print("=== 最终路线推荐 ===")
print(route_description)
if __name__ == "__main__":
main()代码重点说明：
输出结果：
用户需求：我从A_小区到D_医院，下午5点高峰时段出发，换乘次数不要超过1次，步行时间尽量少，优先耗时最短的路线 大模型解析的结构化参数：{'start_point': 'A_小区', 'end_point': 'D_医院', 'constraints': ['换乘次数≤1'], 'preferences': ['优先耗时最短']} 算法求解的最优路径：['A_小区', 'B_商场', 'C_地铁1号线', 'D_医院'] 总耗时：18分钟 线路详情：['1路(公交): A_小区→B_商场 (5分钟)', '1路(公交): B_商场→C_地铁1号线 (5分钟)', '2路(公交): C_地铁1号线→D_医院 (8分钟)'] === 最终路线推荐 === 根据您的需求，这里有一条最优的公交路线供您参考： 路线概述： 起始站：A_小区 终点站：D_医院 行驶路线及时间： 1. 从A_小区出发，乘坐1路公交直达B_商场，全程约5分钟。 2. 在B_商场换乘另一辆1路公交，直接前往C_地铁1号线站，用时也是5分钟。此时，您已经完成了第一次换乘。 3. 在C_地铁1号线站乘坐2路公交，直达D_医院，用时8分钟。 总耗时：整个行程大约需要18分钟，符合您的要求。 温馨提示： * 在换乘时，请注意安全，确保随身携带的物品安全。 * 地铁站内请遵守公共交通规则，文明乘车。 * 如有需要，您可以在途中适当休息，祝您旅途愉快！ 这条路线严格遵循了您的优先耗时最短的偏好，并且语言简洁明了，方便您理解。
真实场景公交网络拓扑图：
简单说，公交规划的本质，就是把整个城市的公交网看成一张图：站点是节点，线路是连线，时间、距离、换乘都是权重。以前靠 Dijkstra经典最短路径算法，只能算最快、最近，规则死板、不够聪明。而大模型一加入，整个系统直接升级：它能听懂我们用自然语言说的“少走路、少换乘、避开高峰”，把模糊需求变成算法能看懂的结构化条件；还能结合实时拥堵、天气、施工这些动态信息，自动调整路线权重。
整个流程也很清晰：先采集公交数据、建好路网，再用大模型解析用户需求，接着用传统算法算出候选路线，最后再由大模型把结果翻译成通俗易懂的出行建议。既保留了算法算得快、算得准的优点，又拥有大模型会理解、会推理、会说话的能力。也是没有想到今天的知识在无意间解答了曾经的疑虑，这或许就是学习的好处吧！