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 模型权重

• DeepSeek-V4-Flash-w8a8-mtp（量化版本）：需要 1 个 Atlas 800 A3（128G × 8）节点或 1 个 Atlas 800 A2（64G × 8）节点。下载模型权重

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

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

如需部署多节点环境，需按照验证多节点通信环境中的说明验证多节点通信。

4 安装

4.1 Docker 镜像安装

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

A3 系列A2 系列

在每个节点上启动 Docker 镜像。

export IMAGE=quay.io/ascend/vllm-ascend:v0.22.1rc1-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

在每个节点上启动 Docker 镜像。

export IMAGE=quay.io/ascend/vllm-ascend:v0.22.1rc1
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 运行成功后，可通过执行 docker ps 命令验证容器服务是否正常运行。

4.2 源码安装

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

• 从源码安装 vllm-ascend，请参考安装指南。

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

5 在线服务部署

Note

在本教程中，我们假设您已将模型权重下载到 /root/.cache/modelscope/hub/models/vllm-ascend/。您可以根据需要将其更改为自己的路径。

建议将以下服务代码封装在 .sh 脚本文件中，并以 Bash 模式执行。

5.1 单节点在线部署

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

A2 系列A3 系列

运行以下脚本执行在线推理。

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 VLLM_ASCEND_ENABLE_FLASHCOMM1=1
export TASK_QUEUE_ENABLE=1
export HCCL_OP_EXPANSION_MODE="AIV"

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 \
    --safetensors-load-strategy 'prefetch' \
    --no-enable-prefix-caching \
    --model-loader-extra-config='{"enable_multithread_load": "true", "num_threads": 128}' \
    --quantization ascend \
    --port 8900 \
    --block-size 128 \
    --speculative-config '{"num_speculative_tokens": 1,"method": "mtp","enforce_eager": true}' \
    --compilation-config '{"cudagraph_mode": "FULL_DECODE_ONLY"}' \
    --async-scheduling \
    --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_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 VLLM_ASCEND_ENABLE_FLASHCOMM1=1
export TASK_QUEUE_ENABLE=1
export HCCL_OP_EXPANSION_MODE="AIV"

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 \
    --safetensors-load-strategy 'prefetch' \
    --model-loader-extra-config='{"enable_multithread_load": "true", "num_threads": 128}' \
    --quantization ascend \
    --port 8900 \
    --block-size 128 \
    --speculative-config '{"num_speculative_tokens": 1,"method": "mtp","enforce_eager": true}' \
    --compilation-config '{"cudagraph_mode": "FULL_DECODE_ONLY"}' \
    --async-scheduling \
    --additional-config '
    {"ascend_compilation_config":{
        "enable_npugraph_ex":true,
        "enable_static_kernel":false
        },
    "enable_cpu_binding": true,
    "multistream_overlap_shared_expert":true}'

关键参数说明：

• --max-model-len 指定最大上下文长度，即单个请求的输入和输出 token 之和。请根据实际场景调整。
• --no-enable-prefix-caching 表示禁用前缀缓存。如需启用，请移除该选项。
• --speculative-config 配置 MTP（多 token 预测）推测解码以加速推理。
• --compilation-config '{"cudagraph_mode":"FULL_DECODE_ONLY"}' 在解码阶段启用全 ACL 图执行，以减少调度延迟。
• --async-scheduling 启用异步调度，使 CPU 调度与 NPU 计算重叠。
• VLLM_ASCEND_ENABLE_FLASHCOMM1=1 启用 FlashComm 通信优化。

常见问题提示：如遇问题，请参考公共 FAQ 进行排查。

服务验证：

curl http://<node0_ip>:8900/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字段。

5.2 多节点 PD 分离部署

我们推荐使用 Mooncake 进行部署：Mooncake。

在标准单节点部署模式下，Prefill（提示处理）和 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（128G × 8）和Atlas 800 A2（64G × 8）多节点环境下的PD分离部署。

5.2.1 A3系列PD分离部署

本节展示在Atlas 800 A3（128G × 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的起始偏移量。
   --dp-address	str	是	-	数据并行主节点的IP地址。
   --dp-rpc-port	str	否	12345	数据并行主节点通信的RPC端口。
   --vllm-start-port	int	否	9000	此节点上每个vLLM引擎实例的起始端口。

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

   1. Prefill节点

      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=2560
      export TASK_QUEUE_ENABLE=1
      export VLLM_ASCEND_ENABLE_FLASHCOMM1=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
      
      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 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}' \
          --no-enable-prefix-caching \
          --safetensors-load-strategy 'prefetch' \
          --speculative-config '{"num_speculative_tokens": 1,"method": "mtp","enforce_eager": true}' \
          --trust-remote-code \
          --block-size 128 \
          --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_shared_expert_dp": true,  "enable_dsa_cp": 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. Decode节点

      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=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
      
      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 1048576 \
          --max-num-batched-tokens 120 \
          --max-num-seqs 60 \
          --async-scheduling \
          --block-size 128 \
          --no-disable-hybrid-kv-cache-manager \
          --no-enable-prefix-caching \
          --safetensors-load-strategy 'prefetch' \
          --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.9 \
          --quantization ascend \
          --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": "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
          }'
      

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

   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
      

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

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

5.2.2 A2系列PD分离部署

本节展示在Atlas 800 A2（64G × 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
      
      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 \
          --async-scheduling \
          --no-disable-hybrid-kv-cache-manager \
          --enable-prefix-caching \
          --trust-remote-code \
          --gpu-memory-utilization 0.9 \
          --quantization ascend \
          --safetensors-load-strategy 'prefetch' \
          --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 \
          --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
                      }
              }
          }'
      

   2. Decode节点（4个D节点共享同一脚本）

      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
      
      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 \
          --async-scheduling \
          --block-size 128 \
          --no-disable-hybrid-kv-cache-manager \
          --no-enable-prefix-caching \
          --trust-remote-code \
          --gpu-memory-utilization 0.9 \
          --quantization ascend \
          --safetensors-load-strategy 'prefetch' \
          --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 \
          --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
          }'
      

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

   1. Prefill节点

      # 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节点

      # 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。

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

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

关键参数说明：

• VLLM_ASCEND_ENABLE_FLASHCOMM1=1：在prefill节点上启用通信优化功能。
• recompute_scheduler_enable: true：启用重计算调度器。当decode节点的KV Cache不足时，请求将被发送到prefill节点重新计算KV Cache。在PD分离场景下，仅在decode节点上启用此配置。
• MooncakeHybridConnector：用于PD分离的KV传输连接器，在prefill和decode节点之间传输KV Cache。
• enable_shared_expert_dp: true：为共享专家启用数据并行，适用于MoE模型。

部署验证：

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

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

5.2.3 超长序列部署

对于超长序列场景，可以通过调整PD（预填充/解码）比例和模型并行策略来提供支持。例如，在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

1. 详细信息请参考使用AISBench。

2. 执行后即可获取结果。

数据集	版本	指标	模式	vllm-api-general-chat	备注
GPQA	-	accuracy	gen	88.17	1 Atlas 800 A3 (128G × 8)
GSM8K	-	accuracy	gen	96.30	1 Atlas 800 A3 (128G × 8)

8 性能评估

使用AISBench

详细信息请参考使用AISBench进行性能评估。

使用vLLM基准测试

更多详细信息请参考vllm benchmark。

9 性能调优

9.1 推荐配置

注意：以下配置在特定测试环境中验证，仅供参考。最佳配置取决于最大输入/输出长度、前缀缓存命中率、精度要求以及部署机器比例等因素。建议根据实际情况参考第9.2节进行调优。

表1：场景概览

*Total NPUs表示所有节点使用的NPU总数。

场景	部署模式	*NPU总数	权重版本	关键考量
高吞吐量	单节点混合	16 (A3)	DeepSeek-V4-Flash-w8a8-mtp	使用dp4 tp4平衡内存容量与计算效率
高吞吐量	1P1D部署	32 (A3)	DeepSeek-V4-Flash-w8a8-mtp	P节点和D节点均使用dp16 tp1；平衡延迟与吞吐量
长上下文（1M）	单节点（A3）	8 (A3)	DeepSeek-V4-Flash-w8a8-mtp	使用dp4 tp4平衡内存容量与计算效率
长上下文（1M）	1P1D部署	32 (A3)	DeepSeek-V4-Flash-w8a8-mtp	P节点和D节点均使用dp16 tp1；平衡延迟与吞吐量

表2：详细节点配置

场景	配置	NPU数	TP	DP	最大序列数	最大批处理Token数	最大模型长度	MTP推测数
High Throughput (A3)	Server / Single Machine	8	4	4	64	10240	1048576	1
Long Context (1M, A3)	Server / Single Machine	8	4	4	64	10240	1048576	1
PD Separation (A3)	Server-P Node	8	4	4	16	8192	1048576	1
PD Separation (A3)	Server-D Node	8	1	16	60	120	1048576	1

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

注意：

max-model-len和max-num-seqs需要根据实际使用场景设置。其他设置请参考部署章节。

目前，我们以实验性方式支持4K前缀缓存命中。您只需将服务中的--block-size值从128改为32即可。

9.2 调优指南

9.2.1 通用调优参考

调优方法请参考公共性能调优文档。

详细功能描述请参考功能指南。

10 常见问题

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