Skip to content

80. MoE Expert Parallel Benchmark | MoE 专家并行基准 ​

难度: Hard | 环境: CPU-first | 标签: 并行通信、MoE、基准对比 | 目标人群: 具备MoE与并行基础的读者

🚀 云端运行环境

本章节的实战代码可以点击以下链接在免费 GPU 算力平台上直接运行:

Open In ColabOpen In Studio (国内推荐:魔搭社区免费实例)


本节导读 ​

把专家分到多张卡上后,同样数量的输入词元可能产生很不一样的耗时:均衡路由让各卡分担计算,热点路由却会使少数专家拥挤,其他设备等待。专家接收数量达到上限时,还要决定超出的分配如何处理,较短的运行时间可能只是少做了工作。

本节从词元选择专家开始,追踪跨进程分发、专家计算和结果返回,比较路由分布怎样改变通信、负载与容量溢出。先用示例记录练习筛选规则,再在多GPU实验中观察均衡与偏斜路由的真实时间和数量变化。

关键词: MoE、expert parallel、routing、capacity


前置阅读 ​

先理解词元如何选择专家,以及多个进程如何接收和返回数据,再比较路由形态带来的代价。


Step 1:追踪词元到专家再返回的过程 ​

MoE(混合专家)用路由器为每个输入词元选择Top-k个专家,即得分最高的k个计算分支。专家并行把专家分布到不同进程;rank是进程编号,目标专家在远端时就要传输词元状态。All-to-All(全互换)让各进程按目标分组发送数据,专家计算完成后再把结果返回来源进程。

完整MoE层还要恢复词元顺序,并按路由权重合并多个专家的结果。路由较均衡时,各进程有机会同时结束;流量集中到少数专家时,最忙的进程会拖长本轮计算。

路由形态主要去向可能增加的代价观察对象
本地路由本进程的专家本地热点与容量不足各专家分配量
均衡跨卡路由多个进程均匀接收跨卡分发与返回传输字节、各进程耗时
偏斜跨卡路由少数热点专家容量溢出与等待超额分配、最慢进程耗时

完整MoE层的路由、专家执行与结果合并

Step 2:区分输入词元与专家接收的路由项 ​

一个词元选中两个专家,会产生两个“词元—专家”路由项。例如100个词元、每个选择2个专家,总共要处理200项分配;若其中20项超过容量,接收的路由项为180,但完成的原始词元数还取决于每个词元是否保留了所需专家结果。专家容量表示单个专家本轮最多接收多少路由项,溢出表示超过这个上限的部分。

不同系统可以丢弃、重路由或延迟处理溢出项,因此比较吞吐时要先确定所计数的工作量。路由项每秒适合分析分发与专家执行,原始词元吞吐与模型质量则要在结果合并后检查。

数量计算方式解释什么
原始词元数输入词元数量模型收到多少输入
分配路由项数词元数×每个词元选择的专家数各专家合计收到多少分配
专家容量单个专家允许接收的路由项上限本轮可接收多少工作
溢出路由项数超出各专家容量的分配之和哪些分配未按原计划执行
已接收路由项数总分配减去被丢弃的溢出项当前丢弃策略下进入专家计算的数量

Step 3:把完成数量与耗时一起比较 ​

只有计数与计时范围相同,速率才有比较意义。偏斜路由若丢弃更多分配,运行更快未必更有效:应同时列出已接收路由项、溢出数量、分发与返回字节以及最慢进程耗时,再判断热点是否真正缓解。负载偏斜还要区分专家之间与进程之间;同一进程上的两个专家一忙一闲,进程总负载可能仍然接近其他进程。

进入完整模型后,再用恢复顺序并合并后的输出检查质量,并记录成功完成的迭代数占全部尝试的比例。分发返回实验中的形状正确、数值有限,只能检查这段计算是否正常完成;质量与原始词元吞吐需要完整模型结果。

相同输入下比较路由负载与容量代价

Step 4:比较路由记录并筛选候选 ​

题目提供本地、均衡与偏斜三组示例记录。effective_tokens沿用原字段名,在本练习中表示已接收并完成专家计算的路由项数;由它除以秒数得到路由项每秒。imbalance为输入记录中给定的负载偏斜指标,successful_step_ratio为成功迭代数占尝试次数的比例;它们不是下面简化GPU实验直接生成的完整模型指标。先计算速率与基线差值,再结合容量、通信和成功比例筛选候选。

任务与目的已知条件完成标准测试验证
TODO 1:汇总完成数量与速率各路由记录中的已接收路由项和耗时用实际接收量计算速率,并保留通信与溢出溢出后完成量与输入分配量不同
TODO 2:比较候选与基线本地基线与一个跨进程候选计算速率、通信、偏斜、溢出和成功比例的差值各项差值的单位与方向
TODO 3:决定复测或调整速率收益与各项阈值全部满足时进入GPU复测,有收益但部分超限时调整,否则退回基线ready_for_gpu / tune / reject三条路径
python
from typing import Dict, List
python
def summarize_moe_parallel_runs(runs: list[dict[str, float]]) -> dict[str, object]:
    """TODO 1:汇总多种路由形态的有效工作量与系统代价。"""
    # total_effective_tokens = ???
    # mean_comm_ms = ???
    # max_overflow = ???
    # best_effective_throughput_run = ???  # effective_tokens / duration_ms * 1000
    raise NotImplementedError("请先完成 TODO 代码!")

def compare_moe_parallel_to_baseline(baseline: dict[str, float], candidate: dict[str, float]) -> dict[str, float]:
    """TODO 2:计算 candidate 相对 baseline 的收益和代价。"""
    # effective_throughput_gain = ???
    # comm_delta_ms = ???
    # overflow_delta = ???
    # imbalance_delta = ???
    raise NotImplementedError("请先完成 TODO 代码!")

def recommend_moe_parallel_run(
    baseline: dict[str, float],
    candidate: dict[str, float],
    max_imbalance: float,
    min_successful_step_ratio: float,
    max_overflow: float = 0.0,
    max_comm_increase_ms: float = 12.0,
) -> dict[str, object]:
    """TODO 3:按路由项速率、容量、通信和成功迭代比例筛选候选。"""
    # capacity_ok = ???
    # communication_ok = ???
    # decision = ???
    raise NotImplementedError("请先完成 TODO 代码!")
python
# 测试你的实现
def test_moe_parallel_decision():
    """检查路由项速率、基线差值与三类候选决策。"""
    baseline = {'name': 'local', 'comm_ms': 40, 'imbalance': 0.25, 'duration_ms': 10000, 'successful_step_ratio': 0.82, 'overflow': 0, 'effective_tokens': 1000}
    candidate = {'name': 'cross_rank_balanced', 'comm_ms': 48, 'imbalance': 0.12, 'duration_ms': 8000, 'successful_step_ratio': 0.80, 'overflow': 0, 'effective_tokens': 1000}
    skewed = {'name': 'cross_rank_skewed', 'comm_ms': 47, 'imbalance': 0.72, 'duration_ms': 6000, 'successful_step_ratio': 0.80, 'overflow': 280, 'effective_tokens': 720}
    summary = summarize_moe_parallel_runs([baseline, candidate, skewed])
    assert summary['run_count'] == 3
    assert summary['best_effective_throughput_run'] == 'cross_rank_balanced'
    assert summary['total_effective_tokens'] == 2720
    assert summary['max_overflow'] == 280
    comparison = compare_moe_parallel_to_baseline(baseline, candidate)
    assert comparison['comm_delta_ms'] == 8
    assert comparison['imbalance_delta'] == -0.13
    assert comparison['effective_throughput_gain'] == 25
    assert comparison['overflow_delta'] == 0
    assert comparison['successful_step_ratio_delta'] == -0.02
    decision = recommend_moe_parallel_run(baseline, candidate, max_imbalance=0.15, min_successful_step_ratio=0.78)
    assert decision['decision'] == 'ready_for_gpu'
    assert decision['next_action'] == 'run_cluster_evaluation'
    skewed_decision = recommend_moe_parallel_run(baseline, skewed, max_imbalance=0.15, min_successful_step_ratio=0.78)
    assert skewed_decision['decision'] == 'tune'
    unstable = {**candidate, 'successful_step_ratio': 0.60}
    assert recommend_moe_parallel_run(baseline, unstable, 0.15, 0.78)['decision'] == 'reject'


test_moe_parallel_decision()
print('✅ 路由项速率、容量溢出与候选决策通过基础校验。')

🛑 STOP HERE 🛑









请先尝试自己完成代码并跑通测试。
如果你正在 Colab 中运行,并且遇到困难没有思路,可以向下滚动查看参考答案。










参考代码与解析 ​

代码 ​

python
def summarize_moe_parallel_runs(runs: list[dict[str, float]]) -> dict[str, object]:
    """TODO 1:汇总多种路由形态的有效工作量与系统代价。"""
    if not runs:
        return {'run_count': 0, 'total_effective_tokens': 0, 'mean_comm_ms': 0.0, 'max_overflow': 0.0, 'best_effective_throughput_run': None}
    for item in runs:
        if item.get('duration_ms', 0.0) <= 0:
            raise ValueError('duration_ms 必须大于 0')
    best = max(runs, key=lambda item: item['effective_tokens'] / item['duration_ms'])
    return {
        'run_count': len(runs),
        'total_effective_tokens': sum(item.get('effective_tokens', item.get('tokens', 0.0)) for item in runs),
        'mean_comm_ms': sum(item.get('comm_ms', 0.0) for item in runs) / len(runs),
        'max_overflow': max(item.get('overflow', 0.0) for item in runs),
        'best_effective_throughput_run': best.get('name', 'run'),
    }


def compare_moe_parallel_to_baseline(baseline: dict[str, float], candidate: dict[str, float]) -> dict[str, float]:
    """比较候选与基线,速率差单位为路由项每秒。"""
    baseline_throughput = baseline['effective_tokens'] / baseline['duration_ms'] * 1000
    candidate_throughput = candidate['effective_tokens'] / candidate['duration_ms'] * 1000
    return {
        'comm_delta_ms': candidate.get('comm_ms', 0.0) - baseline.get('comm_ms', 0.0),
        'imbalance_delta': round(candidate.get('imbalance', 0.0) - baseline.get('imbalance', 0.0), 4),
        'effective_throughput_gain': candidate_throughput - baseline_throughput,
        'overflow_delta': candidate.get('overflow', 0.0) - baseline.get('overflow', 0.0),
        'successful_step_ratio_delta': round(candidate.get('successful_step_ratio', 0.0) - baseline.get('successful_step_ratio', 0.0), 4),
    }


def recommend_moe_parallel_run(
    baseline: dict[str, float],
    candidate: dict[str, float],
    max_imbalance: float,
    min_successful_step_ratio: float,
    max_overflow: float = 0.0,
    max_comm_increase_ms: float = 12.0,
) -> dict[str, object]:
    """按速率收益及容量、通信和稳定性约束筛选候选。"""
    comparison = compare_moe_parallel_to_baseline(baseline, candidate)
    if (
        comparison['effective_throughput_gain'] > 0
        and candidate.get('imbalance', 10**9) <= max_imbalance
        and candidate.get('successful_step_ratio', -10**9) >= min_successful_step_ratio
        and candidate.get('overflow', 10**9) <= max_overflow
        and comparison['comm_delta_ms'] <= max_comm_increase_ms
    ):
        return {'decision': 'ready_for_gpu', 'reason': '示例中的路由项速率、负载、容量、通信和成功比例均达标', 'next_action': 'run_cluster_evaluation'}
    if comparison['effective_throughput_gain'] > 0 and candidate.get('successful_step_ratio', -10**9) >= min_successful_step_ratio:
        return {'decision': 'tune', 'reason': '路由项速率增加,但容量、负载或通信仍需调整', 'next_action': 'refine_router_capacity_or_placement'}
    return {'decision': 'reject', 'reason': '收益不足或成功迭代比例不达标', 'next_action': 'fallback_to_parallel_baseline'}

解析 ​

TODO 1:按已完成数量计算速率 ​

  • 用effective_tokens / duration_ms比较各组速率,计算每秒速率时再乘1000。示例中偏斜路由只完成720个路由项,应使用720而不是原计划的1000。
  • 汇总返回总完成量、平均通信时间和最大溢出量;这些值分别说明做了多少工作和付出什么代价。

TODO 2:保持基线差值的单位与方向 ​

  • 各项差值均为“候选减基线”:速率差为正表示增加,通信时间、偏斜和溢出差为正则表示代价增加。
  • effective_throughput_gain是路由项每秒的绝对差。例如100增至125返回25,而不是25%的比例值。

TODO 3:同时满足收益与约束 ​

  • 速率增加且负载、成功比例、溢出与通信增量全部达标时返回ready_for_gpu;仍有收益但容量或通信需调整时返回tune。
  • 收益不足或成功比例不足时返回reject。三类测试分别检查进入真实复测、调整配置和退回基线,CPU示例不产生多卡采用结论。

Step 5:多GPU比较均衡与偏斜路由 ​

5.1 环境、输入与固定条件 ​

使用通信与并行实验Quickstart中的PAR-CUDA-MECHANISM环境,至少需要两张可见CUDA GPU。实验执行All-to-All分发、每个进程的一套本地矩阵计算和All-to-All返回,比较均衡与偏斜路由。当前简化路径没有为每个专家配置独立权重,也没有恢复原词元顺序和完成Top-k加权合并;返回形状和有限值检查对应这段往返计算。

脚本已经记录各专家分配量、容量和溢出路由项。received_tokens_per_rank沿用原字段名,计数的是每进程接收的路由项。配置中的EXPERTS_PER_RANK尚未接入命令;专家总数、Top-k和容量系数采用脚本默认值,运行前应核对输出工作负载中的实际值。

固定对象记录内容作用
输入每进程词元数、隐藏维、精度保持输入数量与张量大小一致
路由与容量实际专家总数、Top-k、容量系数解释接收量与溢出量
分布式执行进程数、GPU、NCCL、预热与重复次数比较相同硬件上的均衡与偏斜路由
输出各组原始JSON与汇总JSON复核时间、负载、通信字节、峰值显存和失败
python
# 5.1:默认关闭;真实 EP 机制基准至少需要两张 CUDA GPU。
RUN_GPU_EXPERIMENT = False
WORLD_SIZE = 2
EXPERTS_PER_RANK = 1  # 每个 rank 持有一个本地 expert;项目 backend 可扩展多个 expert。
TOKENS_PER_RANK = 256
HIDDEN_SIZE = 1024
DTYPE = 'bf16'
WARMUP = 2
REPEATS = 5
from tools.project_runtime import resolve_project_root
RESULT_DIR = resolve_project_root() / 'benchmarks/results/80_moe_dispatch'
ROUTE_MODES = ['balanced', 'skewed']  # 只改变路由负载分布。
SUMMARY_PATH = f'{RESULT_DIR}/summary.json'
print({'run': RUN_GPU_EXPERIMENT, 'world_size': WORLD_SIZE, 'experts_per_rank': EXPERTS_PER_RANK, 'route_modes': ROUTE_MODES, 'summary': SUMMARY_PATH})
REFERENCE_PATH = f'{RESULT_DIR}/summary_reference.json'  # 供 81 消费的稳定资产引用。

5.2 多卡环境预检 ​

检查 CUDA、可见 GPU 数与 torchrun,再开始 all-to-all 路由实验。

python
# 5.2:默认关闭;开启时检查多卡条件。
GPU_READY = False
if RUN_GPU_EXPERIMENT:
    import shutil, torch
    GPU_READY = torch.cuda.is_available() and torch.cuda.device_count() >= WORLD_SIZE and shutil.which('torchrun') is not None
    print({'visible_gpus': torch.cuda.device_count(), 'world_size': WORLD_SIZE, 'ready': GPU_READY})
else:
    print({'run': False, 'required_gpus': WORLD_SIZE})

5.3 核对实验组与输出路径 ​

G0和G1运行相同分发与返回路径,只改变路由分布;本地路由是CPU示例中的对照,没有在当前GPU命令中执行。G2为可选完整MoE后端结果,需要提供原词元输出、质量和端到端时间。

python
# 5.3:每组的 JSON 由 5.4 写入 RESULT_DIR;G2 留给真实 MoE backend。
EXPERIMENT_GROUPS = {'G0': 'balanced', 'G1': 'skewed', 'G2': 'real_moe_backend'}
print(EXPERIMENT_GROUPS)

5.4 执行并保存原始测量 ​

按均衡与偏斜两组路由运行分发、计算和返回,分别保存原始JSON,再汇总结果。

python
# 5.4:运行均匀与偏斜 EP 对照并汇总结果;默认关闭。
import subprocess
from pathlib import Path

if RUN_GPU_EXPERIMENT and GPU_READY:
    Path(RESULT_DIR).mkdir(parents=True, exist_ok=True)
    result_paths = []
    for route_mode in ROUTE_MODES:
        output = Path(RESULT_DIR) / f'{route_mode}.json'
        command = ['torchrun', '--standalone', f'--nproc_per_node={WORLD_SIZE}', 'tools/run_parallel_mechanism_benchmark.py', '--mode', 'ep_dispatch', '--routing', route_mode, '--output', str(output), '--tokens-per-rank', str(TOKENS_PER_RANK), '--hidden-dim', str(HIDDEN_SIZE), '--warmup', str(WARMUP), '--repeats', str(REPEATS), '--dtype', 'bfloat16' if DTYPE == 'bf16' else 'float32']
        print(' '.join(command))
        subprocess.run(command, check=False)
        result_paths.append(str(output))
    summary_command = ['python', 'tools/aggregate_distributed_evidence.py', '--project', '80', '--output', SUMMARY_PATH] + sum((['--input', path] for path in result_paths), [])
    subprocess.run(summary_command, check=True)
elif RUN_GPU_EXPERIMENT:
    print('多卡预检未通过;请先检查 5.2 输出。')
else:
    print('GPU benchmark 默认关闭。')

5.5 读取结果与生成来源引用 ​

先核对两组实际输入和路由配置,再比较接收路由项、容量溢出、最慢进程耗时与跨卡字节。下方单元同时写出供下游读取的来源引用文件。

python
# 5.5:读取项目 companion,并生成供 81 使用的稳定资产引用。
import json
from pathlib import Path

from tools.distributed_result_schema import validate_record
from tools.project_asset_relations import make_asset_reference

if Path(SUMMARY_PATH).exists():
    result = json.loads(Path(SUMMARY_PATH).read_text(encoding="utf-8"))
    errors = validate_record(result)
    if errors:
        raise ValueError("80 companion 不符合 distributed-benchmark/v1:" + "; ".join(errors))
    reference = make_asset_reference("distributed.moe_dispatch", SUMMARY_PATH)
    Path(REFERENCE_PATH).write_text(json.dumps(reference, ensure_ascii=False, indent=2), encoding="utf-8")
    print({"decision": result["decision"], "sources": len(result.get("sources", [])), "reference": REFERENCE_PATH})
else:
    print(f"尚无 dispatch companion:{SUMMARY_PATH}")

5.6 解释结果与决定复测方向 ​

先解释更短的时间是否伴随更多溢出,再决定调整容量、路由或专家放置。当前实验的数值检查是返回形状与有限值,完整模型的输出质量需要另行对照。

读取项判断与下一步
运行状态先区分启动、显存不足与All-to-All错误
比较条件核对输入数量、进程数、专家数、Top-k、容量系数和精度
负载与容量同时查看各专家容量前分配量、接收路由项和溢出比例
时间与传输比较最慢进程耗时、跨卡分发与往返字节、峰值显存
完整模型复测恢复词元顺序并加权合并后,检查质量、成功迭代比例与原始词元吞吐,再决定是否采用

相关阅读 ​

需要改变路由目标时回到负载均衡机制;需要比较训练状态分片时进入另一类并行基准。

Released under the MIT License.