DeepSeek-V4-Flash¶

1 简介¶

DeepSeek-V4 相较于 DeepSeek-V3 引入了多项关键升级：

• 流形约束超连接（mHC），用于增强传统残差连接。
• 一种混合注意力架构，通过 Compress-4-Attention 和 Compress-128-Attention 大幅提升长上下文效率。对于混合专家（MoE）组件，它仍采用 DeepSeekMoE 架构，仅做少量调整。

DeepSeek-V4-Flash 是 DeepSeek-V4 系列中的轻量级变体，适用于高吞吐量和低延迟服务场景。

本文档将展示模型的主要验证步骤，包括支持的功能、功能配置、环境准备、单节点和多节点部署、精度和性能评估。

2 支持的功能¶

参见 支持功能列表 以获取模型支持的功能矩阵。

参见 功能指南 以获取功能配置。

3 前提条件¶

3.1 模型权重¶

建议将模型权重下载到多节点共享目录，例如 /root/.cache/。

路径说明：将模型权重下载到任意目录并记录该目录。确保后续部署命令中的模型路径与该目录一致。

3.2 验证多节点通信（可选）¶

如果要部署多节点环境，需要根据 验证多节点通信环境 验证多节点通信。

4 安装¶

4.1 Docker 镜像安装¶

根据机器类型选择镜像，并在节点上启动 Docker 镜像，参见 使用 Docker。

注意：DSpark 在 vLLM Ascend v0.25.0 及更高版本中同时支持 A2 和 A3。对于 A2，请使用镜像 quay.io/ascend/vllm-ascend:DeepSeekV4-flash-0731；对于 A3，请使用镜像 quay.io/ascend/vllm-ascend:DeepSeekV4-flash-0731-a3。

export IMAGE=quay.io/ascend/vllm-ascend:v0.23.0-a3
docker run --rm \
    --name vllm-ascend \
    --shm-size=512g \
    --net=host \
    --privileged=true \
    --device /dev/davinci0 \
    --device /dev/davinci1 \
    --device /dev/davinci2 \
    --device /dev/davinci3 \
    --device /dev/davinci4 \
    --device /dev/davinci5 \
    --device /dev/davinci6 \
    --device /dev/davinci7 \
    --device /dev/davinci8 \
    --device /dev/davinci9 \
    --device /dev/davinci10 \
    --device /dev/davinci11 \
    --device /dev/davinci12 \
    --device /dev/davinci13 \
    --device /dev/davinci14 \
    --device /dev/davinci15 \
    --device /dev/davinci_manager \
    --device /dev/devmm_svm \
    --device /dev/hisi_hdc \
    -v /usr/local/dcmi:/usr/local/dcmi \
    -v /usr/local/Ascend/driver/tools/hccn_tool:/usr/local/Ascend/driver/tools/hccn_tool \
    -v /usr/local/bin/npu-smi:/usr/local/bin/npu-smi \
    -v /usr/local/Ascend/driver/lib64/:/usr/local/Ascend/driver/lib64/ \
    -v /usr/local/Ascend/driver/version.info:/usr/local/Ascend/driver/version.info \
    -v /etc/ascend_install.info:/etc/ascend_install.info \
    -v /etc/hccn.conf:/etc/hccn.conf \
    -v /root/.cache:/root/.cache \
    -it $IMAGE bash

# deepseek-v4-flash uses the following image
export IMAGE=quay.io/ascend/vllm-ascend:v0.23.0

# deepseek-v4-flash-dspark uses the following image
export IMAGE=quay.io/ascend/vllm-ascend:nightly-main

docker run --rm \
    --name vllm-ascend \
    --shm-size=512g \
    --net=host \
    --privileged=true \
    --device /dev/davinci0 \
    --device /dev/davinci1 \
    --device /dev/davinci2 \
    --device /dev/davinci3 \
    --device /dev/davinci4 \
    --device /dev/davinci5 \
    --device /dev/davinci6 \
    --device /dev/davinci7 \
    --device /dev/davinci_manager \
    --device /dev/devmm_svm \
    --device /dev/hisi_hdc \
    -v /usr/local/dcmi:/usr/local/dcmi \
    -v /usr/local/Ascend/driver/tools/hccn_tool:/usr/local/Ascend/driver/tools/hccn_tool \
    -v /usr/local/bin/npu-smi:/usr/local/bin/npu-smi \
    -v /usr/local/Ascend/driver/lib64/:/usr/local/Ascend/driver/lib64/ \
    -v /usr/local/Ascend/driver/version.info:/usr/local/Ascend/driver/version.info \
    -v /etc/ascend_install.info:/etc/ascend_install.info \
    -v /etc/hccn.conf:/etc/hccn.conf \
    -v /root/.cache:/root/.cache \
    -it $IMAGE bash

成功执行 docker run 后，可以通过执行 docker ps 命令验证正在运行的容器服务。

4.2 源代码安装¶

如果不想使用上述 Docker 镜像，也可以从源代码构建所有内容：

• 从源代码安装 vllm-ascend，参见 安装。

如果要部署多节点环境，需要在每个节点上配置环境。

5 在线服务部署¶

5.1 单节点在线部署¶

单节点部署在同一节点内完成 Prefill 和 Decode。量化模型 DeepSeek-V4-Flash-w8a8-mtp 可部署在 1 台 Atlas 800 A3（128GB × 8）或 1 台 Atlas 800 A2（64GB × 8）上。

export OMP_PROC_BIND=false
export OMP_NUM_THREADS=10
export PYTORCH_NPU_ALLOC_CONF=expandable_segments:True
export LD_PRELOAD=/usr/lib/aarch64-linux-gnu/libjemalloc.so.2:$LD_PRELOAD
export HCCL_BUFFSIZE=1024
export TASK_QUEUE_ENABLE=1
export HCCL_OP_EXPANSION_MODE="AIV"

# Ensure the model path matches the directory recorded during download
vllm serve /root/.cache/modelscope/hub/models/vllm-ascend/DeepSeek-V4-Flash-w8a8-mtp \
    --max-model-len 133120 \
    --max-num-batched-tokens 8192 \
    --served-model-name dsv4 \
    --gpu-memory-utilization 0.9 \
    --max-num-seqs 32 \
    --data-parallel-size 1 \
    --tensor-parallel-size 8 \
    --enable-expert-parallel \
    --tokenizer-mode deepseek_v4 \
    --tool-call-parser deepseek_v4 \
    --enable-auto-tool-choice \
    --reasoning-parser deepseek_v4 \
    --no-enable-prefix-caching \
    --model-loader-extra-config='{"enable_multithread_load": true, "num_threads": 128}' \
    --quantization ascend \
    --port 8000 \
    --block-size 128 \
    --attention_config.indexer_kv_dtype int8 \
    --speculative-config '{"num_speculative_tokens": 1,"method": "mtp","enforce_eager": true}' \
    --compilation-config '{"cudagraph_mode": "FULL_DECODE_ONLY"}' \
    --additional-config '
    {"ascend_compilation_config":{
        "enable_npugraph_ex":true,
        "enable_static_kernel":false
        },
    "enable_cpu_binding": true,
    "enable_dsa_cp": true,
    "multistream_overlap_shared_expert": true}'

export OMP_NUM_THREADS=10
export PYTORCH_NPU_ALLOC_CONF=expandable_segments:True
export LD_PRELOAD=/usr/lib/aarch64-linux-gnu/libjemalloc.so.2:$LD_PRELOAD
export HCCL_BUFFSIZE=1024
export TASK_QUEUE_ENABLE=1
export HCCL_OP_EXPANSION_MODE=AIV

# Ensure the model path matches the directory recorded during download
vllm serve /root/.cache/modelscope/hub/models/UploadWeight/DeepSeek-V4-Flash-DSpark-w4a8-test \
    --max-model-len 800000 \
    --max-num-batched-tokens 8192 \
    --served-model-name dsv4 \
    --gpu-memory-utilization 0.9 \
    --max-num-seqs 32 \
    --data-parallel-size 1 \
    --tensor-parallel-size 8 \
    --enable-expert-parallel \
    --tokenizer-mode deepseek_v4 \
    --tool-call-parser deepseek_v4 \
    --enable-auto-tool-choice \
    --reasoning-parser deepseek_v4 \
    --no-disable-hybrid-kv-cache-manager \
    --model-loader-extra-config='{"enable_multithread_load": true, "num_threads": 128}' \
    --quantization ascend \
    --port 8000 \
    --block-size 128 \
    --attention_config.indexer_kv_dtype int8 \
    --speculative-config '{"method": "dspark", "num_speculative_tokens": 7, "enforce_eager": true}'  \
    --compilation-config '{"cudagraph_mode": "FULL_DECODE_ONLY"}'

export OMP_PROC_BIND=false
export OMP_NUM_THREADS=10
export PYTORCH_NPU_ALLOC_CONF=expandable_segments:True
export LD_PRELOAD=/usr/lib/aarch64-linux-gnu/libjemalloc.so.2:$LD_PRELOAD
export HCCL_BUFFSIZE=1024
export TASK_QUEUE_ENABLE=1
export HCCL_OP_EXPANSION_MODE="AIV"
export VLLM_PREFIX_CACHE_RETENTION_INTERVAL=4096

# Ensure the model path matches the directory recorded during download
vllm serve /root/.cache/modelscope/hub/models/vllm-ascend/DeepSeek-V4-Flash-w8a8-mtp \
    --max-model-len 1048576 \
    --max-num-batched-tokens 10240 \
    --served-model-name dsv4 \
    --gpu-memory-utilization 0.9 \
    --api-server-count 1 \
    --max-num-seqs 64 \
    --data-parallel-size 4 \
    --tensor-parallel-size 4 \
    --enable-expert-parallel \
    --tokenizer-mode deepseek_v4 \
    --tool-call-parser deepseek_v4 \
    --enable-auto-tool-choice \
    --reasoning-parser deepseek_v4 \
    --model-loader-extra-config='{"enable_multithread_load": true, "num_threads": 128}' \
    --quantization ascend \
    --port 8000 \
    --block-size 32 \
    --attention_config.indexer_kv_dtype int8 \
    --speculative-config '{"num_speculative_tokens": 1,"method": "mtp","enforce_eager": true}' \
    --compilation-config '{"cudagraph_mode": "FULL_DECODE_ONLY"}' \
    --additional-config '
    {"ascend_compilation_config":{
        "enable_npugraph_ex": true,
        "enable_static_kernel": false
        },
    "enable_cpu_binding": true,
    "multistream_overlap_shared_expert": true}'

export OMP_PROC_BIND=false
export OMP_NUM_THREADS=10
export PYTORCH_NPU_ALLOC_CONF=expandable_segments:True
export LD_PRELOAD=/usr/lib/aarch64-linux-gnu/libjemalloc.so.2:$LD_PRELOAD
export HCCL_BUFFSIZE=1024
export TASK_QUEUE_ENABLE=1
export HCCL_OP_EXPANSION_MODE="AIV"
export VLLM_PREFIX_CACHE_RETENTION_INTERVAL=4096

# Ensure the model path matches the directory recorded during download
vllm serve /path/to/DeepSeek-V4-Flash-0731-w8a8 \
    --max-model-len 1048576 \
    --max-num-batched-tokens 10240 \
    --served-model-name dsv4 \
    --gpu-memory-utilization 0.9 \
    --max-num-seqs 64 \
    --data-parallel-size 4 \
    --tensor-parallel-size 4 \
    --enable-expert-parallel \
    --tokenizer-mode deepseek_v4 \
    --tool-call-parser deepseek_v4 \
    --enable-auto-tool-choice \
    --reasoning-parser deepseek_v4 \
    --model-loader-extra-config='{"enable_multithread_load": true, "num_threads": 128}' \
    --quantization ascend \
    --port 8000 \
    --block-size 32 \
    --attention_config.indexer_kv_dtype int8 \
    --speculative-config '{"method":"dspark","num_speculative_tokens":7,"enforce_eager":true}' \
    --compilation-config '{"cudagraph_mode": "FULL_DECODE_ONLY"}' \
    --additional-config '{
        "ascend_compilation_config": {
            "enable_npugraph_ex": true,
            "enable_static_kernel": false
        },
        "enable_cpu_binding": true,
        "enable_dsa_cp": true,
        "multistream_overlap_shared_expert": true
    }'

关键参数说明：

• --max-model-len 指定最大上下文长度，即单个请求的输入和输出 Token 之和。请根据实际场景进行调整。
• --max-num-seqs 表示每个 DP 组允许处理的最大请求数。如果发送到服务的请求数超过此限制，超出的请求将保持等待状态，不会被调度。请注意，等待状态所花费的时间也会计入 TTFT 和 TPOT 等指标。因此，在测试性能时，通常建议 --max-num-seqs * --data-parallel-size >= 实际总并发数。
• --max-num-batched-tokens 是一个调度器步骤中处理的最大 Token 数。较大的值可以提高 Prefill 效率，但会消耗更多激活内存。
• --data-parallel-size 设置全局数据并行 rank 数，而 --tensor-parallel-size 设置每个 DP rank 内的张量并行大小。请根据部署拓扑和可用 NPU 数量一起配置。
• --enable-expert-parallel 为 MoE 层启用专家并行。请勿在同一 MoE 层中混合使用 MoE 张量并行和专家并行。
• --no-enable-prefix-caching 表示禁用前缀缓存。若要启用，请移除此选项。
• --block-size 设置 KV 缓存块大小。若要启用实验性的 4k 前缀缓存命中支持，请将其从 128 更改为 32。
• --quantization ascend 为 W8A8 模型启用 Ascend 量化。
• --speculative-config 配置投机解码以加速推理。对于多 Token 预测（MTP），使用 mtp；对于 DSpark 模型，使用 dspark。使用 DSpark 时，num_speculative_tokens 必须至少为 5（请检查检查点的 config.json）。
• --compilation-config '{"cudagraph_mode":"FULL_DECODE_ONLY"}' 在解码阶段启用完整 ACL 图执行，以降低调度延迟。
• --additional-config 启用 Ascend 特定优化。enable_npugraph_ex 启用增强 ACL 图执行，enable_static_kernel: false 保持禁用静态内核编译，enable_cpu_binding 启用 Ascend 原生 CPU 绑定，enable_dsa_cp 启用 DSA 上下文并行，multistream_overlap_shared_expert 重叠共享专家计算以获得更好的 MoE 吞吐量。
• VLLM_PREFIX_CACHE_RETENTION_INTERVAL：控制混合注意力层前缀缓存检查点的保留间隔（以 Token 计）。它适用于 DeepSeek-V4，并且仅在前缀缓存启用时生效。在 KV 缓存压力下，它可以提高可复用长前缀的有效前缀缓存命中率。该值必须是 --block-size 的非负倍数；对于 DeepSeek-V4-Flash，建议为 --block-size 的 128 倍。当 --block-size 为 32 时，将其设置为 4096；当 --block-size 为 128 时，将其设置为 16384。

常见问题提示：如果遇到问题，请参阅 公共常见问题解答 进行故障排查。

服务验证：

curl http://<node0_ip>:8000/v1/chat/completions \
    -H "Content-Type: application/json" \
    -d '{
        "model": "dsv4",
        "messages": [
            {
                "role": "user",
                "content": "Who are you?"
            }
        ],
        "max_tokens": 256,
        "temperature": 0
    }'

预期结果：

服务返回 HTTP 200 OK，并返回包含 choices 字段的 JSON 响应。

5.2 多节点 PD 分离部署¶

我们建议使用 Mooncake 进行部署：Mooncake。

在标准单节点部署模式下，Prefill（Prompt 处理）和 Decode（Token 生成）任务运行在同一组 NPU 上。这可能导致两个问题：

1. Prefill 抢占中断 Decode：Prefill 是计算密集型任务，会一次性处理整个输入上下文，而 Decode 逐个生成 Token。当新的用户请求到达时，其 Prefill 阶段可能抢占并中断正在进行的 Decode 任务，导致抖动和更高的每个输出 Token 时间（TPOT）延迟。
2. 资源分配不灵活：Prefill 和 Decode 的计算特性根本不同——Prefill 受计算限制且内存带宽密集，而 Decode 受内存带宽限制。将它们运行在同一硬件上会迫使做出折中，无法使任何一方达到最优。

PD（Prefill-Decode）分离通过在专用节点组上分别运行 Prefill 和 Decode 来解决这些问题，每个节点组独立配置。对于具有并发多用户工作负载的生产部署，该架构是推荐方案，因为此类场景同时需要稳定的延迟和高吞吐量。

以下章节分别描述在 Atlas 800 A3（128GB × 8）和 Atlas 800 A2（64GB × 8）多节点环境上的 PD 分离部署。

5.2.1 A3 系列 PD 分离部署¶

本节展示在 Atlas 800 A3（128GB × 8）多节点环境中，使用 1P1D 部署 DeepSeek-V4-Flash 以获得更好性能的部署指南。

开始之前，请：

1. 在每个节点上准备脚本 launch_online_dp.py。

   import argparse
   import multiprocessing
   import os
   import subprocess
   import sys
   
   def parse_args():
       parser = argparse.ArgumentParser()
       parser.add_argument(
           "--dp-size",
           type=int,
           required=True,
           help="Data parallel size."
       )
       parser.add_argument(
           "--tp-size",
           type=int,
           default=1,
           help="Tensor parallel size."
       )
       parser.add_argument(
           "--dp-size-local",
           type=int,
           default=-1,
           help="Local data parallel size."
       )
       parser.add_argument(
           "--dp-rank-start",
           type=int,
           default=0,
           help="Starting rank for data parallel."
       )
       parser.add_argument(
           "--dp-address",
           type=str,
           required=True,
           help="IP address for data parallel master node."
       )
       parser.add_argument(
           "--dp-rpc-port",
           type=str,
           default=12345,
           help="Port for data parallel master node."
       )
       parser.add_argument(
           "--vllm-start-port",
           type=int,
           default=9000,
           help="Starting port for the engine."
       )
       return parser.parse_args()
   
   args = parse_args()
   dp_size = args.dp_size
   tp_size = args.tp_size
   dp_size_local = args.dp_size_local
   if dp_size_local == -1:
       dp_size_local = dp_size
   dp_rank_start = args.dp_rank_start
   dp_address = args.dp_address
   dp_rpc_port = args.dp_rpc_port
   vllm_start_port = args.vllm_start_port
   
   def run_command(visible_devices, dp_rank, vllm_engine_port):
       command = [
           "bash",
           "./run_dp_template.sh",
           visible_devices,
           str(vllm_engine_port),
           str(dp_size),
           str(dp_rank),
           dp_address,
           dp_rpc_port,
           str(tp_size),
       ]
       subprocess.run(command, check=True)
   
   if __name__ == "__main__":
       template_path = "./run_dp_template.sh"
       if not os.path.exists(template_path):
           print(f"Template file {template_path} does not exist.")
           sys.exit(1)
   
       processes = []
       num_cards = dp_size_local * tp_size
       for i in range(dp_size_local):
           dp_rank = dp_rank_start + i
           vllm_engine_port = vllm_start_port + i
           visible_devices = ",".join(str(x) for x in range(i * tp_size, (i + 1) * tp_size))
           process = multiprocessing.Process(target=run_command,
                                           args=(visible_devices, dp_rank,
                                                   vllm_engine_port))
           processes.append(process)
           process.start()
   
       for process in processes:
           process.join()
   

参数说明：

|参数|类型|必填|默认值|描述|
|---------|----|--------|-------|-----------|
|`--dp-size`|int|是|-|数据并行大小（所有节点上 DP rank 的总数）。|
|`--tp-size`|int|否|1|每个 DP rank 内的张量并行大小。|
|`--dp-size-local`|int|否|（与 `--dp-size` 相同）|当前节点上的 DP rank 数量。如果未设置，默认为 `--dp-size`。|
|`--dp-rank-start`|int|否|0|此节点上数据并行 rank 的起始 rank 偏移。|
|`--dp-address`|str|是|-|数据并行主节点的 IP 地址。|
|`--dp-rpc-port`|str|否|12345|数据并行主通信的 RPC 端口。|
|`--vllm-start-port`|int|否|9000|此节点上每个 vLLM 引擎实例的起始端口。|

1. 在每个节点上准备脚本 run_dp_template.sh。

=== "A3 系列与 dspark" {#a3-series-with-dspark}

1. 预填充节点

    ```shell
    nic_name="xxxx" # change to your own nic name
    local_ip=xx.xx.xx.1 # change to your own ip

    export HCCL_IF_IP=$local_ip
    export GLOO_SOCKET_IFNAME=$nic_name
    export TP_SOCKET_IFNAME=$nic_name
    export HCCL_SOCKET_IFNAME=$nic_name
    export VLLM_RPC_TIMEOUT=3600000
    export VLLM_EXECUTE_MODEL_TIMEOUT_SECONDS=30000
    export HCCL_EXEC_TIMEOUT=204
    export HCCL_CONNECT_TIMEOUT=120
    export OMP_PROC_BIND=false
    export OMP_NUM_THREADS=10
    export PYTORCH_NPU_ALLOC_CONF=expandable_segments:True
    export HCCL_BUFFSIZE=1800
    export TASK_QUEUE_ENABLE=1
    export HCCL_OP_EXPANSION_MODE="AIV"
    export LD_PRELOAD=/usr/lib/aarch64-linux-gnu/libjemalloc.so.2:$LD_PRELOAD
    export ASCEND_RT_VISIBLE_DEVICES=$1
    export VLLM_ASCEND_ENABLE_FUSED_MC2=1
    export VLLM_PREFIX_CACHE_RETENTION_INTERVAL=4096

    # Ensure the model path matches the directory recorded during download
    vllm serve /path/to/DeepSeek-V4-Flash-0731-w8a8 \
        --host 0.0.0.0 \
        --port $2 \
        --data-parallel-size $3 \
        --data-parallel-rank $4 \
        --data-parallel-address $5 \
        --data-parallel-rpc-port $6 \
        --tensor-parallel-size $7 \
        --enable-expert-parallel \
        --seed 1024 \
        --served-model-name dsv4 \
        --max-model-len 1048576 \
        --max-num-batched-tokens 8192 \
        --max-num-seqs 16 \
        --no-disable-hybrid-kv-cache-manager \
        --model-loader-extra-config='{"enable_multithread_load": true, "num_threads": 128}' \
        --speculative-config '{"num_speculative_tokens": 5,"method": "dspark","enforce_eager": true}' \
        --trust-remote-code \
        --block-size 32 \
        --attention_config.indexer_kv_dtype int8 \
        --tokenizer-mode deepseek_v4 \
        --tool-call-parser deepseek_v4 \
        --enable-auto-tool-choice \
        --reasoning-parser deepseek_v4 \
        --gpu-memory-utilization 0.9 \
        --quantization ascend \
        --enforce-eager \
        --additional-config '{"enable_cpu_binding": true, "enable_dsa_cp": true, "enable_flashcomm1":true}' \
        --kv-transfer-config \
        '{"kv_connector": "MooncakeHybridConnector",
        "kv_role": "kv_producer",
        "kv_port": "30000",
        "engine_id": "0",
        "kv_connector_extra_config": {
                    "prefill": {
                            "dp_size": 4,
                            "tp_size": 4
                    },
                    "decode": {
                            "dp_size": 16,
                            "tp_size": 1
                    }
            }
        }'
    ```

2. 解码节点

    ```shell
    nic_name="xxxx" # change to your own nic name
    local_ip=xx.xx.xx.2 # change to your own ip

    export LD_PRELOAD=/usr/lib/aarch64-linux-gnu/libjemalloc.so.2:$LD_PRELOAD
    export HCCL_OP_EXPANSION_MODE="AIV"
    export TASK_QUEUE_ENABLE=1
    export VLLM_RPC_TIMEOUT=3600000
    export VLLM_EXECUTE_MODEL_TIMEOUT_SECONDS=30000
    export HCCL_EXEC_TIMEOUT=204
    export HCCL_CONNECT_TIMEOUT=120
    export HCCL_IF_IP=$local_ip
    export GLOO_SOCKET_IFNAME=$nic_name
    export TP_SOCKET_IFNAME=$nic_name
    export HCCL_SOCKET_IFNAME=$nic_name
    export OMP_PROC_BIND=false
    export OMP_NUM_THREADS=10
    export PYTORCH_NPU_ALLOC_CONF=expandable_segments:True
    export HCCL_BUFFSIZE=2400
    export ASCEND_RT_VISIBLE_DEVICES=$1

    # Ensure the model path matches the directory recorded during download
    vllm serve /path/to/DeepSeek-V4-Flash-0731-w8a8 \
        --host 0.0.0.0 \
        --port $2 \
        --data-parallel-size $3 \
        --data-parallel-rank $4 \
        --data-parallel-address $5 \
        --data-parallel-rpc-port $6 \
        --tensor-parallel-size $7 \
        --enable-expert-parallel \
        --seed 1024 \
        --served-model-name dsv4 \
        --max-model-len 1048576 \
        --max-num-batched-tokens 480 \
        --max-num-seqs 60 \
        --async-scheduling \
        --block-size 32 \
        --attention_config.indexer_kv_dtype int8 \
        --no-disable-hybrid-kv-cache-manager \
        --no-enable-prefix-caching \
        --trust-remote-code \
        --tokenizer-mode deepseek_v4 \
        --model-loader-extra-config='{"enable_multithread_load": true, "num_threads": 128}' \
        --tool-call-parser deepseek_v4 \
        --enable-auto-tool-choice \
        --reasoning-parser deepseek_v4 \
        --gpu-memory-utilization 0.95 \
        --quantization ascend \
        --speculative-config '{"num_speculative_tokens": 5,"method": "dspark","enforce_eager": true}' \
        --compilation-config '{"cudagraph_mode": "FULL_DECODE_ONLY","cudagraph_capture_sizes": [12, 24, 48, 96, 192, 256, 288, 360]}' \
        --kv-transfer-config \
        '{"kv_connector": "MooncakeHybridConnector",
        "kv_role": "kv_consumer",
        "kv_port": "30100",
        "engine_id": "1",
        "kv_connector_extra_config": {
                    "prefill": {
                            "dp_size": 4,
                            "tp_size": 4
                    },
                    "decode": {
                            "dp_size": 16,
                            "tp_size": 1
                    }
            }
        }' \
        --additional-config '{
            "ascend_compilation_config":{
                "enable_npugraph_ex":true,
                "enable_static_kernel":false
            },
            "enable_cpu_binding":true,
            "multistream_overlap_shared_expert":true,
            "recompute_scheduler_enable":true
        }'
    ```

1. 在每个节点上使用以下命令启动服务。

   1. Prefill 节点

      # change ip to your own
      python launch_online_dp.py --dp-size 4 --tp-size 4 --dp-size-local 4 --dp-rank-start 0 --dp-address xx.xx.xx.1 --dp-rpc-port 12321 --vllm-start-port 7100
      

   2. Decode 节点

      # change ip to your own
      python launch_online_dp.py --dp-size 16 --tp-size 1 --dp-size-local 16 --dp-rank-start 0 --dp-address xx.xx.xx.2 --dp-rpc-port 12321 --vllm-start-port 7100
      

2. 部署 P-D 分离代理。

   请参考 Prefill-Decode 分离（Deepseek） 部署 P-D 分离代理。

5.2.2 A2 系列 PD 分离部署¶

本节介绍在 Atlas 800 A2（64GB × 8）多节点环境中，采用 4*1P 1*4D 部署 DeepSeek-V4-Flash 以获得更好性能的部署指南。

开始之前，请：

1. 在每个节点上准备脚本 launch_online_dp.py。

   import argparse
   import multiprocessing
   import os
   import subprocess
   import sys
   
   def parse_args():
       parser = argparse.ArgumentParser()
       parser.add_argument("--dp-size", type=int, required=True, help="Data parallel size.")
       parser.add_argument("--tp-size", type=int, default=1, help="Tensor parallel size.")
       parser.add_argument("--dp-size-local", type=int, default=-1, help="Local data parallel size.")
       parser.add_argument("--dp-rank-start", type=int, default=0, help="Starting rank for data parallel.")
       parser.add_argument("--dp-address", type=str, required=True, help="IP address for data parallel master node.")
       parser.add_argument("--dp-rpc-port", type=str, default=12345, help="Port for data parallel master node.")
       parser.add_argument("--vllm-start-port", type=int, default=9000, help="Starting port for the engine.")
       return parser.parse_args()
   
   args = parse_args()
   dp_size = args.dp_size
   tp_size = args.tp_size
   dp_size_local = args.dp_size_local
   if dp_size_local == -1:
       dp_size_local = dp_size
   dp_rank_start = args.dp_rank_start
   dp_address = args.dp_address
   dp_rpc_port = args.dp_rpc_port
   vllm_start_port = args.vllm_start_port
   
   def run_command(visible_devices, dp_rank, vllm_engine_port):
       command = [
           "bash",
           "./run_dp_template.sh",
           visible_devices,
           str(vllm_engine_port),
           str(dp_size),
           str(dp_rank),
           dp_address,
           dp_rpc_port,
           str(tp_size),
       ]
       subprocess.run(command, check=True)
   
   if __name__ == "__main__":
       template_path = "./run_dp_template.sh"
       if not os.path.exists(template_path):
           print(f"Template file {template_path} does not exist.")
           sys.exit(1)
   
       processes = []
       num_cards = dp_size_local * tp_size
       for i in range(dp_size_local):
           dp_rank = dp_rank_start + i
           vllm_engine_port = vllm_start_port + i
           visible_devices = ",".join(str(x) for x in range(i * tp_size, (i + 1) * tp_size))
           process = multiprocessing.Process(target=run_command, args=(visible_devices, dp_rank, vllm_engine_port))
           processes.append(process)
           process.start()
   
       for process in processes:
           process.join()
   

2. 在每个节点上准备脚本 run_dp_template.sh。

   1. Prefill 节点（4 个 P 节点共用同一脚本）

      对于每个 P 实例，只需修改以下两个配置值：kv_port 和 engine_id。engine_id 应从 0 开始依次递增，而 kv_port（例如 30100）必须对每个 P 实例唯一，例如 30000、30100 等。

      unset ftp_proxy
      unset https_proxy
      unset http_proxy
      rm -rf ~/ascend/log
      
      nic_name="xxxxxx" #eg."enp67s0f0np0"
      local_ip=`hostname -I|awk -F " " '{print$1}'`
      
      export LD_PRELOAD=/usr/lib/aarch64-linux-gnu/libjemalloc.so.2:$LD_PRELOAD
      export HCCL_OP_EXPANSION_MODE="AIV"
      export TASK_QUEUE_ENABLE=1
      export VLLM_RPC_TIMEOUT=3600000
      export VLLM_EXECUTE_MODEL_TIMEOUT_SECONDS=30000
      export HCCL_EXEC_TIMEOUT=204
      export HCCL_CONNECT_TIMEOUT=1200
      
      export HCCL_IF_IP=$local_ip
      export GLOO_SOCKET_IFNAME=$nic_name
      export TP_SOCKET_IFNAME=$nic_name
      export HCCL_SOCKET_IFNAME=$nic_name
      export OMP_PROC_BIND=false
      export OMP_NUM_THREADS=10
      export PYTORCH_NPU_ALLOC_CONF=expandable_segments:True
      export HCCL_BUFFSIZE=1024
      
      export ASCEND_RT_VISIBLE_DEVICES=$1
      export TASK_QUEUE_ENABLE=1
      
      # Ensure the model path matches the directory recorded during download
      vllm serve /root/.cache/modelscope/hub/models/vllm-ascend/DeepSeek-V4-Flash-w8a8-mtp \
          --host 0.0.0.0 \
          --port $2 \
          --data-parallel-size $3 \
          --data-parallel-rank $4 \
          --data-parallel-address $5 \
          --data-parallel-rpc-port $6 \
          --tensor-parallel-size $7 \
          --enable-expert-parallel \
          --seed 1024 \
          --served-model-name dsv4 \
          --max-model-len 135000 \
          --max-num-batched-tokens 4096 \
          --max-num-seqs 16 \
          --block-size 128 \
          --enforce-eager \
          --no-disable-hybrid-kv-cache-manager \
          --trust-remote-code \
          --gpu-memory-utilization 0.9 \
          --quantization ascend \
          --model-loader-extra-config='{"enable_multithread_load": true, "num_threads": 128}' \
          --tokenizer-mode deepseek_v4 \
          --tool-call-parser deepseek_v4 \
          --enable-auto-tool-choice \
          --reasoning-parser deepseek_v4 \
          --attention_config.indexer_kv_dtype int8 \
          --additional-config '{"enable_cpu_binding": true, "enable_shared_expert_dp": true}' \
          --speculative-config '{"num_speculative_tokens": 1, "method": "mtp","enforce_eager": true}' \
          --kv-transfer-config \
          '{"kv_connector": "MooncakeHybridConnector",
          "kv_role": "kv_producer",
          "kv_port": "30000",
          "engine_id": "0",
          "kv_connector_extra_config": {
                      "prefill": {
                          "dp_size": 8,
                          "tp_size": 1
                      },
                      "decode": {
                          "dp_size": 32,
                          "tp_size": 1
                      }
              }
          }'
      

3. Decode 节点（4 个 D 节点共享同一脚本） {#2-decode-node-4-d-nodes-share-the-same-script}

   ```shell
   unset ftp_proxy
   unset https_proxy
   unset http_proxy
   rm -rf ~/ascend/log
   
   nic_name="xxxxxx" #eg."enp67s0f0np0"
   local_ip=`hostname -I|awk -F " " '{print$1}'`
   
   export LD_PRELOAD=/usr/lib/aarch64-linux-gnu/libjemalloc.so.2:$LD_PRELOAD
   export HCCL_OP_EXPANSION_MODE="AIV"
   export TASK_QUEUE_ENABLE=1
   export VLLM_RPC_TIMEOUT=3600000
   export VLLM_EXECUTE_MODEL_TIMEOUT_SECONDS=30000
   export HCCL_EXEC_TIMEOUT=204
   export HCCL_CONNECT_TIMEOUT=1200
   
   export HCCL_IF_IP=$local_ip
   export GLOO_SOCKET_IFNAME=$nic_name
   export TP_SOCKET_IFNAME=$nic_name
   export HCCL_SOCKET_IFNAME=$nic_name
   export OMP_PROC_BIND=false
   export OMP_NUM_THREADS=10
   export PYTORCH_NPU_ALLOC_CONF=expandable_segments:True
   export HCCL_BUFFSIZE=1024
   
   export ASCEND_RT_VISIBLE_DEVICES=$1
   
   # Ensure the model path matches the directory recorded during download
   vllm serve /root/.cache/modelscope/hub/models/vllm-ascend/DeepSeek-V4-Flash-w8a8-mtp \
       --host 0.0.0.0 \
       --port $2 \
       --data-parallel-size $3 \
       --data-parallel-rank $4 \
       --data-parallel-address $5 \
       --data-parallel-rpc-port $6 \
       --tensor-parallel-size $7 \
       --enable-expert-parallel \
       --seed 1024 \
       --served-model-name dsv4 \
       --max-model-len 135000 \
       --max-num-batched-tokens 60 \
       --max-num-seqs 30 \
       --block-size 128 \
       --no-disable-hybrid-kv-cache-manager \
       --no-enable-prefix-caching \
       --trust-remote-code \
       --gpu-memory-utilization 0.9 \
       --quantization ascend \
       --model-loader-extra-config='{"enable_multithread_load": true, "num_threads": 128}' \
       --tokenizer-mode deepseek_v4 \
       --tool-call-parser deepseek_v4 \
       --enable-auto-tool-choice \
       --reasoning-parser deepseek_v4 \
       --attention_config.indexer_kv_dtype int8 \
       --speculative-config '{"num_speculative_tokens": 1, "method": "mtp","enforce_eager": true}' \
       --compilation-config '{"cudagraph_mode": "FULL_DECODE_ONLY"}' \
       --kv-transfer-config \
       '{"kv_connector": "MooncakeHybridConnector",
       "kv_role": "kv_consumer",
       "kv_port": "30400",
       "engine_id": "4",
       "kv_connector_extra_config": {
                   "prefill": {
                       "dp_size": 8,
                       "tp_size": 1
                   },
                   "decode": {
                       "dp_size": 32,
                       "tp_size": 1
                   }
           }
       }' \
       --additional-config '{
           "ascend_compilation_config":{
                 "enable_npugraph_ex":true,
                 "enable_static_kernel":false
           },
          "enable_cpu_binding":true,
          "multistream_overlap_shared_expert":true,
          "recompute_scheduler_enable":true
       }'
   ```
   

4. 在每个节点上使用以下命令启动服务。 {#3-start-the-server-with-the-following-command-on-each-node}

   1. Prefill 节点 {#1-prefill-node}

      # change ip to your own
      python launch_online_dp.py --dp-size 8 --tp-size 1 --dp-size-local 8 --dp-rank-start 0 --dp-address x.x.x.x --dp-rpc-port 12321 --vllm-start-port 7100
      

      对于每个 P 实例，只有 --dp-address 参数不同，必须配置为与其他实例处于同一子网内的服务 IP 地址。

   2. Decode 节点 {#2-decode-node}

      # change ip to your own
      python launch_online_dp.py --dp-size 32 --tp-size 1 --dp-size-local 8 --dp-rank-start x --dp-address x.x.x.x --dp-rpc-port 12321 --vllm-start-port 7100
      

      对于每个 D 实例，只有 --dp-rank-start 参数不同，应分别设置为 0、8、16 和 24。每个实例的 --dp-address 必须设置为主 D 节点的 IP 地址，即 --dp-rank-start 为 0 的 Decode 实例的 IP。

5. 部署 P-D 分离代理。 {#4-deploy-the-p-d-disaggregation-proxy}

   该代理的实现同样参考了 Prefill-Decode 分离（Deepseek）。

关键参数说明： {#key-parameter-descriptions}

• --no-disable-hybrid-kv-cache-manager 保持混合 KV Cache 管理器处于启用状态。DeepSeek-V4 KV Pool 部署需要此标志；否则，服务在启动过程中可能会 OOM。
• --enforce-eager 强制 Prefill 节点采用 eager 执行，而不是图编译。
• kv_connector_extra_config.prefill.dp_size/tp_size 和 decode.dp_size/tp_size 必须与 Prefill 和 Decode 两侧实际全局 DP 与 TP 配置保持一致。
• recompute_scheduler_enable: true：启用重计算调度器。当 Decode 节点的 KV Cache 不足时，请求将被发送到 Prefill 节点以重新计算 KV Cache。在 PD 分离场景中，仅需在 Decode 节点上启用此配置。
• speculative-config：启用 DSpark 时，Prefill 和 Decode 必须使用相同数量的投机 token，且 num_speculative_tokens 至少为 5（请检查 checkpoint 的 config.json）。对于 MTP，我们建议将 Prefill 设置为 1，将 Decode 设置为实际的投机 token 数量。
• MooncakeHybridConnector：用于 PD 分离的 KV 传输连接器，负责在 Prefill 和 Decode 节点之间传输 KV Cache。
• enable_shared_expert_dp: true：为共享专家启用数据并行，适用于 MoE 模型。
• VLLM_PREFIX_CACHE_RETENTION_INTERVAL：控制混合注意力层前缀缓存（prefix-cache）检查点的保留间隔（以 token 数计）。适用于 DeepSeek-V4，且仅在启用前缀缓存时生效。在 KV Cache 压力较大时，该参数可提高可复用长前缀的有效前缀缓存命中率。该值必须是 --block-size 的非负整数倍；对于 DeepSeek-V4-Flash，建议设置为 --block-size 的 128 倍。当 --block-size 为 32 时，设置为 4096；当 --block-size 为 128 时，设置为 16384。
• VLLM_ASCEND_ENABLE_FUSED_MC2=1：启用融合 MoE 计算（MC2）优化，将共享专家和路由专家的计算合并到融合内核中，以减少启动开销并提升 MoE 推理吞吐量。
• cudagraph_capture_sizes（位于 --compilation-config 中）：Decode 阶段 ACL 图捕获的 batch size 档位。vLLM 会为这些 batch size 预编译计算图，以避免运行时编译开销。在 DSpark 模式（num_speculative_tokens=5）下，每个序列每步处理 6 个 token（1 个真实 token + 5 个投机 token），因此实际并发数 ≈ batch_size / 6（例如 360 → 60 并发）。如果未设置，vLLM 会按需自动捕获；当并发模式可预测时，应显式设置。

部署验证：

PD 分离服务完全启动后，通过 Prefill 主节点上的代理端口发送请求，以验证 Prefill 和 Decode 节点是否协同工作正常。有关代理验证方法，请参阅 Prefill-Decode 分离（Deepseek）。

常见问题提示：如果在 PD 分离部署中遇到问题，请参阅 公共常见问题 进行故障排查。

5.2.3 超长序列部署¶

对于超长序列场景，可以通过调整 PD（Prefill/Decode）比例和模型并行策略来实现支持。例如，在 1M 序列场景中，可以使用 1*4P-1*4D 比例，并将模型并行设置为 DP4TP8 模式。

6 功能验证¶

服务器启动后，您可以使用输入提示词查询模型：

在 : 中，使用主节点的 IP 地址和端口号。如果主备节点分离，则使用代理节点的 IP 地址和端口号。

curl http://<node0_ip>:<port>/v1/chat/completions \
    -H "Content-Type: application/json" \
    -d '{
        "model": "dsv4",
        "messages": [
            {
                "role": "user",
                "content": "Who are you?"
            }
        ],
        "max_tokens": 256,
        "temperature": 0
    }'

预期结果：

服务返回 HTTP 200 OK，JSON 响应中包含 choices 字段。

7 精度评估¶

以下是使用 AISBench 进行精度评估的方法。

7.1 使用 AISBench¶

1. 有关详细信息，请参阅 使用 AISBench。

2. 执行后，您可以获取结果。

8 性能评估¶

8.1 使用 AISBench¶

有关详细信息，请参阅 使用 AISBench 进行性能评估。

8.2 使用 vLLM Benchmark¶

有关更多详细信息，请参阅 vllm benchmark。

9 性能调优¶

9.1 推荐配置¶

有关完整的启动命令和参数说明，请参阅 第 5 章 中的部署示例。

9.2 调优指南¶

9.2.1 通用调优参考¶

有关调优方法，请参阅 公共性能调优文档。

有关详细功能说明，请参阅 功能矩阵。

10 常见问题¶

对于常见环境、安装和通用参数问题，请参阅 公共常见问题；本章仅涵盖特定模型的问题。