DeepSeek 简介

DeepSeek-R1 是一款参数规模达671B的大型语言模型，在近期破圈并广为人知，其满血版部署对硬件要求极高

昇腾 910B NPU 凭借64GB 显存/卡的遥遥领先特性，结合华为自研的MindIE框架，可支持多机多卡分布式推理

昇腾910B部署DeepSeek-R1

【全网最全】昇腾 910B 部署满血版 DeepSeek-R1实用教程+踩坑记录

华为官方部署deepseek-r1教程

本章基于昇腾社区官方文档、知乎技术文章及开发者实践经验，系统梳理从环境准备到服务化测试的全流程，助力高效部署

软硬件要求

硬件配置

基础配置：

  • bf16：至少4台Atlas 800I A2（8*64G）服务器，每台配置8张昇腾910B卡（共32卡，显存总量≥2TB）
  • W8A8量化：若使用W8A8量化权重，可缩减至2台服务器

以下是华为官方给出的其他版本模型的部署资源最低要求及推理性能，供参考

昇腾一体机推荐配置：DeepSeek V3/R1及蒸馏模型推理服务部署推荐配置

模型名称 参数 产品 配置 系统吞吐 (Token/s) 多用户并发数 (路)
DeepSeek V3 671B Atlas 800I A2 1024GB 1911 192
DeepSeek R1 671B Atlas 800I A2 1024GB 1911 192
DeepSeek-R1 Distill-Llama-70B 70B Atlas 800I A2 512GB 3300 165
DeepSeek-R1 Distill-Qwen-32B 32B Atlas 800I A2 256GB 4940 247
DeepSeek-R1 Distill-Qwen-14B 14B Atlas 800I A2 256GB 7500 300
DeepSeek-R1 Distill-Qwen-14B 14B Atlas 300I Duo 1*Duo 96GB PCIE 730 80
DeepSeek-R1 Distill-Llama-8B 8B Atlas 300I Duo 1*Duo 96GB PCIE 956 115
DeepSeek-R1 Distill-Qwen-7B 7B Atlas 300I Duo 1*Duo 96GB PCIE 956 115
DeepSeek-R1 Distill-Qwen-1.5B 1.5B Atlas 300V 1*300V 24GB PCIE 432 16
  • 数据截止至 2025.02.13

网络要求：多机间需高速RDMA网络互联，使用hccn_tool工具检查网卡健康状态。开放端口1025-1030，建议关闭防火墙或配置白名单

服务器：最好在操作前reboot一下服务器，关闭无关进程（如 k8s），避免内存泄漏

软件依赖

组件 版本要求 备注
MindIE ≥2.0.T3 一定要到官网上去下载镜像
CANN ≥8.0.T63 /
昇腾驱动 ≥24.1.rc2 所有节点执行npu-smi info确认驱动版本一致，这个很重要，新驱动能避免大量问题。
操作系统 openeuler24.03 一定要换成欧拉的(官方提供的镜像好像就是)
Python 环境 3.11（镜像预置）
MindStudio Msit: br_noncom_MindStudio_8.0.0_POC_20251231分支
HDK 24.1.0

权重处理与转换

权重下载

注意可以直接下载开源的bf16模型

魔塔 deepseek-r1 bf16、hg deepseek-r1 bf16、hg unsloth deepseek-r1 bf16

hg DeepSeek-V3-bf16

魔塔_deepseek-ai-r1-w8a8-mindie：deepseek-ai-r1-w8a8-mindie是deepseek-r1 bf16量化出来的版本，理论上直接下载这个模型就不需要自己做量化了

示例：DeepSeek-R1-bf16下载脚本示例(都需要依赖python，确保磁盘足够大，文件大约占1.4T)：

1
2
3
4
5
6
# 创建模型存放路径和缓存路径
mkdir -p /home/huggingface/pretrained_model
mkdir -p /home/huggingface/huggingface_cache

# 进入目标目录
cd /home/huggingface/pretrained_model

  1. 官方渠道：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    #安装依赖
    pip install -U huggingface_hub

    # 设置环境变量(当前命令行有效)
    export HF_ENDPOINT=https://hf-mirror.com
    # 缓存目录
    export HF_HOME=/home/huggingface/huggingface_cache

    # 开始下载
    huggingface-cli download --resume-download unsloth/DeepSeek-R1-bf16 --local-dir /home/huggingface/pretrained_model/DeepSeek-R1-BF16

  2. 魔塔社区(推荐)：

    1
    2
    3
    4
    5
    #安装依赖
    pip install modelscope

    # 开始下载
    modelscope download --model unsloth/DeepSeek-R1-BF16 --local_dir /home/huggingface/pretrained_model/DeepSeek-R1-BF16

权重转换（FP8转BF16）

如果下载的是BF16的，可以直接跳过这一步

R1 模型发布的权重是 FP8 的，总体规模在 671B，但是华为昇腾卡不支持 FP8，只支持 BF16，因此还需转回到 BF16 类型

  • GPU 侧转换（需支持 FP8 的 NVIDIA 设备）：

    DeepSeek官方没有针对DeepSeek-R1提供新的权重转换脚本，所以复用DeepSeek-V3的权重转换脚本，执行下面的命令

    1
    2
    3
    git clone https://github.com/deepseek-ai/DeepSeek-V3.git
    cd DeepSeek-V3/inference/
    python fp8_cast_bf16.py --input-fp8-hf-path /path/to/DeepSeek-R1 --output-bf16-hf-path /path/to/deepseek-R1-bf16

  • NPU 侧转换：

    目前npu转换脚本不会自动复制tokenizer等文件，需手动操作

    /path/to/DeepSeek-R1 表示DeepSeek-R1原始权重路径，/path/to/deepseek-R1-bf16 表示权重转换后的新权重路径

    1
    2
    3
    git clone https://gitee.com/ascend/ModelZoo-PyTorch.git
    cd ModelZoo-PyTorch/MindIE/LLM/DeepSeek/DeepSeek-V2/NPU_inference
    python fp8_cast_bf16.py --input-fp8-hf-path /path/to/DeepSeek-R1 --output-bf16-hf-path /path/to/deepseek-R1-bf16

由于模型权重较大，请确保您的磁盘有足够的空间放下所有权重，例如DeepSeek-R1在转换前权重约为640G左右，在转换后权重约为1.3T左右

推理作业时，也请确保您的设备有足够的空间加载模型权重，并为推理计算预留空间

量化权重（非必需）

如果你的机器资源充足，这部分不用看，直接往下

如果你想部署量化的版本，可以参考官方文档。DeepSeek-R1模型权重较大，量化权重生成时间较久，请耐心等待；具体时间与校准数据集大小成正比，10条数据大概需花费3小时

目前支持：

  • 生成模型w8a16量化权重，使用histogram量化方式，在CPU上进行运算
  • 生成模型w8a8混合量化权重，使用histogram量化方式 (MLA: w8a8量化，MOE: w8a8 dynamic pertoken量化)

容器准备

昇腾官方出了可以直接部署的镜像，可前往昇腾社区/开发资源下载适配。但需要申请，通过后才能下载

MindIE镜像概述

DeepSeek-R1的镜像包名称：mindie_2.0.T3-800I-A2-py311-openeuler24.03-lts-aarch64.tar.gz

镜像加载后的名称：mindie:2.0.T3-800I-A2-py311-openeuler24.03-lts-aarch64

注意：量化需要使用mindie:2.0.T3版本

镜像拉取：

1
docker pull swr.cn-south-1.myhuaweicloud.com/ascendhub/mindie:2.0.T3-800I-A2-py311-openeuler24.03-lts

完成之后，请使用docker images命令确认查找具体镜像名称与标签

容器启动

(待确认)目前提供的MindIE镜像预置了DeepSeek-R1模型推理脚本，无需再下载模型代码，也无需参考目录结构。(可跳过至获取模型权重)

下载模型启动代码

1
git clone https://gitee.com/ascend/ModelZoo-PyTorch.git

目录结构( ModelZoo-PyTorch-master\MindIE\LLM\DeepSeek )应为如下：

1
2
├── DeepSeek-R1
│   ├── README.md

将第上面下载好的模型权重放置在从上述下载的模型代码的主目录下，放置后的目录结构应为如下：

1
2
3
4
5
6
├── DeepSeek-R1
│   ├── README.md
│   └── 权重文件1
│   .
│   .
│   └── 权重文件n

修改权重目录下config.json文件，将 model_type更改为deepseekv2(全小写且无空格）

注意：不要问为什么是deepseekv2，照着做就可以了😜

权限配置

修改模型文件夹属组为1001，执行权限为750，执行：

1
2
chown -R 1001:1001 /path/to/DeepSeek-R1
chmod -R 750 /path/to/DeepSeek-R1

启动容器

把下载好模型权重的位置，挂载到容器中，可以放到workspace目录下，这样后面部署的时候，就可以使用了

其它的挂载盘都是常规的驱动或者工具，照做即可，其中—name 容器名，-v 挂载下载好的模型 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
docker run -itd --privileged --name=deepseek-r1 --net=host \
   --shm-size 500g \
   --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/hisi_hdc \
   --device /dev/devmm_svm \
   -v /usr/local/dcmi:/usr/local/dcmi \
   -v /usr/bin/hccn_tool:/usr/bin/hccn_tool \
   -v /usr/local/sbin:/usr/local/sbin \
   -v /usr/local/sbin/npu-smi:/usr/local/sbin/npu-smi \
   -v /usr/local/Ascend/driver:/usr/local/Ascend/driver \
   -v /usr/local/Ascend/firmware:/usr/local/Ascend/firmware \
   -v /etc/hccn.conf:/etc/hccn.conf \
   -v xxxxxx/DeepSeek-R1-weight:/workspace \
   swr.cn-south-1.myhuaweicloud.com/ascendhub/mindie:2.0.T3-800I-A2-py311-openeuler24.03-lts \
   bash

多台服务器部署，每台服务器下载同样的模型权重，位置可以不同，但是都需要执行上述启动容器的命令，把挂载盘换一下

容器操作

接下来的操作都默认在容器中

进入容器

假设上述容器名字为deepseek-r1，执行：

1
docker exec -it deepseek-r1 bash

容器检查

用hccn_tool检查网络状态【重要！！重要！！重要！！】

1
2
3
4
5
6
7
8
9
10
11
12
13
14
# 检查物理链接
for i in {0..7}; do hccn_tool -i $i -lldp -g | grep Ifname; done
# 检查链接情况
for i in {0..7}; do hccn_tool -i $i -link -g ; done
# 检查网络健康情况
for i in {0..7}; do hccn_tool -i $i -net_health -g ; done
# 查看侦测ip的配置是否正确
for i in {0..7}; do hccn_tool -i $i -netdetect -g ; done
# 查看网关是否配置正确
for i in {0..7}; do hccn_tool -i $i -gateway -g ; done
# 检查NPU底层tls校验行为一致性，建议全0
for i in {0..7}; do hccn_tool -i $i -tls -g ; done | grep switch
# NPU底层tls校验行为置0操作
for i in {0..7};do hccn_tool -i $i -tls -s enable 0; done

如果有问题，可以先排查下本机是否正常，一般容器内有问题应该是有些目录没有挂载好，可以问一下chatgpt或者deepseek

配置多机多卡文件

文件名称：rank_table_file.json

文件路径：放在与上文模型代码目录相同的位置，没有的话就自己创建一个

首先使用下面这个命令，把每张卡的ip地址记录下来

1
for i in {0..7};do hccn_tool -i $i -ip -g; done

每台机器都执行一次，如果是4台启动的话，就执行4次，但确定一台作为主节点

输出结果参数介绍：

  • server_count：一共使用几台服务器，即节点数。server_list中第一个server为主节点
  • device_id：当前卡的本机编号，取值范围[0, 本机卡数)
  • device_ip：当前卡的ip地址，可通过hccn_tool命令获取
  • rank_id：当前卡的全局编号，取值范围[0, 总卡数)
  • server_id：当前节点的ip地址
  • container_ip：容器ip地址（服务化部署时需要），若无特殊配置，则与server_id相同

查看服务器的ip地址

1
hostname -I

查看docker容器的ip地址

1
docker inspect 容器id | grep "IPAddress"

如果返回为空，可能是使用和宿主机一样的网络，查看容器的网络模式

1
docker inspect 容器id | grep -i '"NetworkMode"'

如果返回为 “NetworkMode”: “host”, 则说明容器使用的是 host 网络，它没有自己的 IP，而是直接用宿主机 IP

下面是四个节点的rank_table_file.json配置文件，对着填好ip地址即可

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
{
    "server_count": "4",
    "server_list": [
        {
            "device": [
                {
                    "device_id": "0",
                    "device_ip": "xxxx",
                    "rank_id": "0"
                },
                {
                    "device_id": "1",
                    "device_ip": "xxxx",
                    "rank_id": "1"
                },
                {
                    "device_id": "2",
                    "device_ip": "xxxx",
                    "rank_id": "2"
                },
                {
                    "device_id": "3",
                    "device_ip": "xxxx",
                    "rank_id": "3"
                },
                {
                    "device_id": "4",
                    "device_ip": "xxxx",
                    "rank_id": "4"
                },
                {
                    "device_id": "5",
                    "device_ip": "xxxx",
                    "rank_id": "5"
                },
                {
                    "device_id": "6",
                    "device_ip": "xxxx",
                    "rank_id": "6"
                },
                {
                    "device_id": "7",
                    "device_ip": "xxxx",
                    "rank_id": "7"
                }
            ],
            "server_id": "xxxx",
            "container_ip": "xxxx"
        },
        {
            "device": [
                {
                    "device_id": "0",
                    "device_ip": "xxxx",
                    "rank_id": "8"
                },
                {
                    "device_id": "1",
                    "device_ip": "xxxx",
                    "rank_id": "9"
                },
                {
                    "device_id": "2",
                    "device_ip": "xxxx",
                    "rank_id": "10"
                },
                {
                    "device_id": "3",
                    "device_ip": "xxxx",
                    "rank_id": "11"
                },
                {
                    "device_id": "4",
                    "device_ip": "xxxx",
                    "rank_id": "12"
                },
                {
                    "device_id": "5",
                    "device_ip": "xxxx",
                    "rank_id": "13"
                },
                {
                    "device_id": "6",
                    "device_ip": "xxxx",
                    "rank_id": "14"
                },
                {
                    "device_id": "7",
                    "device_ip": "xxxx",
                    "rank_id": "15"
                }
            ],
            "server_id": "xxxx",
            "container_ip": "xxxx"
        },
        {
            "device": [
                {
                    "device_id": "0",
                    "device_ip": "xxxx",
                    "rank_id": "16"
                },
                {
                    "device_id": "1",
                    "device_ip": "xxxx",
                    "rank_id": "17"
                },
                {
                    "device_id": "2",
                    "device_ip": "xxxx",
                    "rank_id": "18"
                },
                {
                    "device_id": "3",
                    "device_ip": "xxxx",
                    "rank_id": "19"
                },
                {
                    "device_id": "4",
                    "device_ip": "xxxx",
                    "rank_id": "20"
                },
                {
                    "device_id": "5",
                    "device_ip": "xxxx",
                    "rank_id": "21"
                },
                {
                    "device_id": "6",
                    "device_ip": "xxxx",
                    "rank_id": "22"
                },
                {
                    "device_id": "7",
                    "device_ip": "xxxx",
                    "rank_id": "23"
                }
            ],
            "server_id": "xxxx",
            "container_ip": "xxxx"
        },
        {
            "device": [
                {
                    "device_id": "0",
                    "device_ip": "xxxx",
                    "rank_id": "24"
                },
                {
                    "device_id": "1",
                    "device_ip": "xxxx",
                    "rank_id": "25"
                },
                {
                    "device_id": "2",
                    "device_ip": "xxxx",
                    "rank_id": "26"
                },
                {
                    "device_id": "3",
                    "device_ip": "xxxx",
                    "rank_id": "27"
                },
                {
                    "device_id": "4",
                    "device_ip": "xxxx",
                    "rank_id": "28"
                },
                {
                    "device_id": "5",
                    "device_ip": "xxxx",
                    "rank_id": "29"
                },
                {
                    "device_id": "6",
                    "device_ip": "xxxx",
                    "rank_id": "30"
                },
                {
                    "device_id": "7",
                    "device_ip": "xxxx",
                    "rank_id": "31"
                }
            ],
            "server_id": "xxxx",
            "container_ip": "xxxx"
        }
    ],
    "status": "completed",
    "version": "1.0"
}

不要忘了设置rank_table_file.json文件的权限

1
chmod 640 rank_table_file.json

配置好之后，后续的MindIE推理框架也会参考这个进行启动，不需要再额外设置

配置通信环境变量(WORLD_SIZE指的是显卡数量，注意是显卡的数量，不是机器的数量)

1
2
3
4
5
export ATB_LLM_HCCL_ENABLE=1
export ATB_LLM_COMM_BACKEND="hccl"
export HCCL_CONNECT_TIMEOUT=7200
export WORLD_SIZE=32
export HCCL_EXEC_TIMEOUT=0

精度测试

在镜像里的文件目录中找到/usr/local/Ascend/atb-models/tests/modeltest/run.sh

在所有机器上同时执行测试命令(参数含义参考上文)：

1
bash run.sh pa_bf16 [dataset] ([shots]) [batch_size] [model_name] ([is_chat_model]) [weight_dir] [rank_table_file] [world_size] [node_num] [rank_id_start] [master_address]

性能测试

在跟上面相同目录下运行命令：

1
2
bash run.sh pa_bf16 performance [[256,256]] 16 deepseekv2 /path/to/weights/DeepSeek-R1 /path/to/xxx/ranktable.json 16 2 0 {主节点IP}
# 0 代表从0号卡开始推理，之后的机器依次从8，16，24，31

跑完会生成一个csv文件，里面保存了本次测试的指标

模型推理

容器环境变量配置

每个容器都要执行以下命令：

1
2
3
4
5
export PYTORCH_NPU_ALLOC_CONF=expandable_segments:True
export MIES_CONTAINER_IP=容器ip地址
export RANKTABLEFILE=rank_table_file.json路径
export OMP_NUM_THREADS=1
export NPU_MEMORY_FRACTION=0.95

注意，上述的路径是指容器内的路径，并且每台机器的ip都要对应正确

修改推理参数配置

文件名称：config.json

文件路径：/usr/local/Ascend/mindie/latest/mindie-service/conf/config.json

注意，这个配置文件跟5.2中的config.json名称一致，但位置不一样，修改的含义也不一样，不要混淆

同样也是在容器中，每台机器都要做一样的配置，下面是官方给的配置，建议上下文长度参数设置为32k，当前 4 台机都可以正常部署起来

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
{
    "Version": "1.0.0",
    "LogConfig": {
        "logLevel": "Info",
        "logFileSize": 20,
        "logFileNum": 20,
        "logPath": "logs/mindie-server.log"
    },
    "ServerConfig": {
        "ipAddress": "改成主节点IP",
        "managementIpAddress": "改成主节点IP",
        "port": 1025,
        "managementPort": 1026,
        "metricsPort": 1027,
        "allowAllZeroIpListening": false,
        "maxLinkNum": 1000, //如果是4机，建议300
        "httpsEnabled": false,
        "fullTextEnabled": false,
        "tlsCaPath": "security/ca/",
        "tlsCaFile": [
            "ca.pem"
        ],
        "tlsCert": "security/certs/server.pem",
        "tlsPk": "security/keys/server.key.pem",
        "tlsPkPwd": "security/pass/key_pwd.txt",
        "tlsCrlPath": "security/certs/",
        "tlsCrlFiles": [
            "server_crl.pem"
        ],
        "managementTlsCaFile": [
            "management_ca.pem"
        ],
        "managementTlsCert": "security/certs/management/server.pem",
        "managementTlsPk": "security/keys/management/server.key.pem",
        "managementTlsPkPwd": "security/pass/management/key_pwd.txt",
        "managementTlsCrlPath": "security/management/certs/",
        "managementTlsCrlFiles": [
            "server_crl.pem"
        ],
        "kmcKsfMaster": "tools/pmt/master/ksfa",
        "kmcKsfStandby": "tools/pmt/standby/ksfb",
        "inferMode": "standard",
        "interCommTLSEnabled": false,
        "interCommPort": 1121,
        "interCommTlsCaPath": "security/grpc/ca/",
        "interCommTlsCaFiles": [
            "ca.pem"
        ],
        "interCommTlsCert": "security/grpc/certs/server.pem",
        "interCommPk": "security/grpc/keys/server.key.pem",
        "interCommPkPwd": "security/grpc/pass/key_pwd.txt",
        "interCommTlsCrlPath": "security/grpc/certs/",
        "interCommTlsCrlFiles": [
            "server_crl.pem"
        ],
        "openAiSupport": "vllm"
    },
    "BackendConfig": {
        "backendName": "mindieservice_llm_engine",
        "modelInstanceNumber": 1,
        "npuDeviceIds": [
            [
                0,
                1,
                2,
                3,
                4,
                5,
                6,
                7
            ]
        ],
        "tokenizerProcessNumber": 8,
        "multiNodesInferEnabled": true,
        "multiNodesInferPort": 1120,
        "interNodeTLSEnabled": false,
        "interNodeTlsCaPath": "security/grpc/ca/",
        "interNodeTlsCaFiles": [
            "ca.pem"
        ],
        "interNodeTlsCert": "security/grpc/certs/server.pem",
        "interNodeTlsPk": "security/grpc/keys/server.key.pem",
        "interNodeTlsPkPwd": "security/grpc/pass/mindie_server_key_pwd.txt",
        "interNodeTlsCrlPath": "security/grpc/certs/",
        "interNodeTlsCrlFiles": [
            "server_crl.pem"
        ],
        "interNodeKmcKsfMaster": "tools/pmt/master/ksfa",
        "interNodeKmcKsfStandby": "tools/pmt/standby/ksfb",
        "ModelDeployConfig": {
            "maxSeqLen": 10000,
            "maxInputTokenLen": 2048,
            "truncation": true,
            "ModelConfig": [
                {
                    "modelInstanceType": "Standard",
                    "modelName": "deepseekr1",
                    "modelWeightPath": "/home/data/dsR1_base_step178000",
                    "worldSize": 8,
                    "cpuMemSize": 5,
                    "npuMemSize": -1,
                    "backendType": "atb",
                    "trustRemoteCode": false
                }
            ]
        },
        "ScheduleConfig": {
            "templateType": "Standard",
            "templateName": "Standard_LLM",
            "cacheBlockSize": 128,
            "maxPrefillBatchSize": 8,
            "maxPrefillTokens": 2048,
            "prefillTimeMsPerReq": 150,
            "prefillPolicyType": 0,
            "decodeTimeMsPerReq": 50,
            "decodePolicyType": 0,
            "maxBatchSize": 8,
            "maxIterTimes": 1024,
            "maxPreemptCount": 0,
            "supportSelectBatch": false,
            "maxQueueDelayMicroseconds": 5000
        }
    }
}

开启多机推理，要设置ipAddress为主节点IP并调整显存参数：

1
2
3
4
5
6
{  
   "multilModesInferEnabled": true, 
   "maxSeqLen": 32000, 
   "maxBatchSize": 16, 
   "modelWeightPath": "/weights/DeepSeek-R1"
}

启动推理服务

执行下面命令：

1
cd /usr/local/Ascend/mindie/latest/mindie-servicenohup ./bin/mindieservice_daemon > /workspace/output.log 2>&1 &

执行命令后，首先会打印本次启动所用的所有参数，然后直到出现以下输出，就表示服务启动成功啦

1
Daemon start success!

最后再用curl测试一下服务响应(如果命令执行不了，尝试把结尾的\去掉，整理成一行运行)）：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
curl -X POST http://{ip}:{port}/v1/chat/completions \
     -H "Accept: application/json" \
     -H "Content-Type: application/json" \
     -d '{
       "model": "DeepSeek-R1",
       "messages": [{
         "role": "user",
         "content": "你好"
       }],
       "max_tokens": 20,
       "presence_penalty": 1.03,    
       "frequency_penalty": 1.0,
       "seed": null,
       "temperature": 0.5,
       "top_p": 0.95,
       "stream": true
     }'

以上能看到输出，就算是部署成功了（完结撒花🎉🎉🎉）

实际示例(仅供参考，以上面那个或官网为准)：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
curl http://192.168.xx.xx:xx/v1/chat/completions -H "Content-Type: application/json" -d '{
 "model": "/workspace/model_zoo/DeepSeek-R1-tokenizer",
 "messages": [
    {
      "role": "user",
      "content": "请介绍下DeepSeek-R1模型是什么？"
    }
  ],
  "max_tokens": 512,
  "stream": false
}'

curl http://192.168.xx.xx:xx/v1/completions -H "Content-Type: application/json" -d '{
 "model": "/workspace/model_zoo/DeepSeek-R1-tokenizer",
 "prompt": "请介绍下DeepSeek-R1模型是什么？",
 "max_tokens": 512
}'

常见问题与解决方案

  1. 加载tokenizer失败

    解决方式：检查tokenizer.json 文件是否和官网一致，并且检查一下权限，是否能正常读取

  2. out of memory报错

    解决方式：适当调高NPU_MEMORY_FRACTION环境变量（默认值为0.8），适当调低服务化配置文件config.json中maxSeqLen、maxInputTokenLen、maxPrefillBatchSize、maxPrefillTokens、maxBatchSize等参数

    1
    export NPU_MEMORY_FRACTION=0.96

  3. hccl通信超时报错

    解决方式：配置以下环境变量

    1
    2
    export HCCL_CONNECT_TIMEOUT=7200
    export HCCL_EXEC_TIMEOUT=0

  4. AttributeError：’IbisTokenizer’ object has no atrribute ‘cache_path’

    解决方式：

    Step1: 进入环境终端后执行

    1
    pip show mies_tokenizer

    默认出现类似如下结果，重点查看Location

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    Name: mies_tokenizer
    Version: 0.0.1
    Summary: ibis tokenizer
    Home-page:
    Author:
    Author-email:
    License:
    Location: /usr/local/python3.10.13/lib/python3.10/site-packages
    Requires:
    Required-by:

    Step2: 打开Location路径下的./mies_tokenizer/tokenizer.py文件

    1
    vim /usr/local/python3.10.13/lib/python3.10/site-packages/mies_tokenizer/tokenizer.py

    Step3: 对以下两个函数代码进行修改

    1
    2
    3
    4
    5
    6
    7
    8
    def __del__(self):
    -       dir_path = file_utils.standardize_path(self.cache_path)
    +       cache_path = getattr(self, 'cache_path', None)
    +       if cache_path is None:
    +           return
    +       dir_path = file_utils.standardize_path(cache_path)
            file_utils.check_path_permission(dir_path)
            all_request = os.listdir(dir_path)

    以及

    1
    2
    3
    4
    5
    6
    7
    8
    def _get_cache_base_path(child_dir_name):
            dir_path = os.getenv("LOCAL_CACHE_DIR", None)
            if dir_path is None:
               dir_path = os.path.expanduser("~/mindie/cache")
    -          if not os.path.exists(dir_path):
    -              os.makedirs(dir_path)
    +          os.makedirs(dir_path, exist_ok=True)
               os.chmod(dir_path, 0o750)

  5. UnicodeEncodeError: ‘ascii’ codec can’t encode character \uff5c in position 301:ordinal not in range(128)

    解决方式：这是因为由于系统在写入或打印日志ASCII编码deepseek的词表失败，导致报错，不影响服务化正常运行。如果需要规避，需要/usr/local/Ascend/atb-models/atb_llm/runner/model_runner.py的第145行注释掉：

    1
    print_log(rank, logger.info, f'init tokenizer done: {self.tokenizer}')

  6. 报错“cannot import name ‘shard_checkpoint’ from ‘transforms.modeling_utils’ ”

    解决方式：原因是开发者在量化的时候把transformers更新到了4.48.2，但是transformers从4.47.0版本就把transforms.modeling_utils里面的shard_checkpoint去掉了。所有需要把transformers版本更新到MindIE镜像里面自带的版本，也就是4.44.0

  7. 模型加载过程很慢

    解决方式：执行如下命令

    1
    export OMP_NUM_THREADS=1

  8. 模型效果不对，返回结果中没有 /think 字段

    解决方式：使用openai的接口推理

  9. 出现算子的Aicore或者aivec报错

    解决方式：查看plog(也就是/root/ascend/log/debug)，可以看到大概率是OOM导致的，看看是不是卡的显存被占用了或者是显存分配、seqlen参数配置不合理

  10. 多请求并发，偶现“failed to get engine response”

    解决方案：重计算的bug，需要设置maxSeqLen=maxPrefillTokens进行规避，在下个MindIE版本会正式解决，预计 2 月 28 日左右发版

总结

昇腾 910B 结合 MindIE 框架为 DeepSeek-R1 提供了强大的推理支持

部署过程中需重点关注权重转换一致性、多机通信配置及显存优化策略

随着 MindIE 版本迭代，未来在模型加载速度和算子兼容性上将有进一步提升

昇腾910B部署DeepSeek-V3

华为官方部署deepseek-v3教程

软硬件要求

其他要求同DeepSeek-R1

  • 部署DeepSeek-V3模型用BF16权重进行推理至少需要4台Atlas 800I A2（8*64G）服务器
  • 用W8A8量化权重进行推理则至少需要2台Atlas 800I A2 (8*64G)

权重处理与转换

权重下载

示例：DeepSeek-V3-bf16下载脚本示例(都需要依赖python，确保磁盘足够大，文件大约占1.4T)：

1
2
3
4
5
6
# 创建模型存放路径和缓存路径
mkdir -p /home/huggingface/pretrained_model
mkdir -p /home/huggingface/huggingface_cache

# 进入目标目录
cd /home/huggingface/pretrained_model

  1. 官方渠道：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    #安装依赖
    pip install -U huggingface_hub

    # 设置环境变量(当前命令行有效)
    export HF_ENDPOINT=https://hf-mirror.com
    # 缓存目录
    export HF_HOME=/home/huggingface/huggingface_cache

    # 开始下载
    huggingface-cli download --resume-download unsloth/DeepSeek-V3-bf16 --local-dir /home/huggingface/pretrained_model/DeepSeek-V3-BF16

  2. 魔塔社区(推荐)：

    1
    2
    3
    4
    5
    #安装依赖
    pip install modelscope

    # 开始下载
    modelscope download --model unsloth/DeepSeek-V3-BF16 --local_dir /home/huggingface/pretrained_model/DeepSeek-V3-BF16

权重转换（FP8转BF16）

  • GPU侧权重转换

    1
    2
    3
    git clone https://github.com/deepseek-ai/DeepSeek-V3.git
    cd DeepSeek-V3/inferece/
    python fp8_cast_bf16.py --input-fp8-hf-path /path/to/DeepSeek-V3 --output-bf16-hf-path /path/to/DeepSeek-V3-bf16

  • NPU侧权重转换 目前npu转换脚本不会自动复制tokenizer等文件

    1
    2
    3
    git clone https://gitee.com/ascend/ModelZoo-PyTorch.git
    cd ModelZoo-PyTorch\MindIE\LLM\DeepSeek\DeepSeek-V2\NPU_inference
    python fp8_cast_bf16.py --input-fp8-hf-path /path/to/DeepSeek-V3 --output-bf16-hf-path /path/to/DeepSeek-V3-bf16

注意：

  • /path/to/DeepSeek-V3 表示DeepSeek-V3原始权重路径，/path/to/DeepSeek-V3-bf16 表示权重转换后的新权重路径
  • 由于模型权重较大，请确保您的磁盘有足够的空间放下所有权重，例如DeepSeek-V3在转换前权重约为640G左右，在转换后权重约为1.4T左右
  • 推理作业时，也请确保您的设备有足够的空间加载模型权重，并为推理计算预留空间

量化权重（非必需）

详情请参考 DeepSeek模型量化方法介绍

目前支持：

  • 生成模型w8a16量化权重，使用histogram量化方式，在CPU上进行运算
  • 生成模型w8a8混合量化权重，使用histogram量化方式 (MLA:w8a8量化，MOE:w8a8 dynamic pertoken量化)

注意：DeepSeek-R1模型权重较大，量化权重生成时间较久，请耐心等待；具体时间与校准数据集大小成正比，10条数据大概需花费3小时

容器准备

前往昇腾社区/开发资源下载适配

DeepSeek-V3的镜像包：mindie_2.0.T3-800I-A2-py311-openeuler24.03-lts-aarch64.tar.gz 镜像加载后的名称：mindie:2.0.T3-800I-A2-py311-openeuler24.03-lts-aarch64

注意：量化需要使用mindie:2.0.T3版本

完成之后，请使用docker images命令确认查找具体镜像名称与标签

1
docker load -i mindie:2.0.T3-800I-A2-py311-openeuler24.03-lts-aarch64(下载的镜像名称与标签)

各组件版本配套如下：

组件 版本
MindIE 2.0.T3
CANN 8.0.T63
PTA 6.0.T700
MindStudio Msit: br_noncom_MindStudio_8.0.0_POC_20251231分支
HDK 24.1.0

容器启动

准备模型

目前提供的MindIE镜像预置了DeepSeek-V3模型推理脚本，无需再下载模型代码，也无需参考目录结构。（可跳过至获取模型权重）

  • 下载对应模型代码，可以使用：
1
git clone https://gitee.com/ascend/ModelZoo-PyTorch.git

目录结构应为如下：

1
2
├── DeepSeek-V3
│   ├── README.md

  • 获取模型权重

    • 本地已有模型权重从您信任的来源自行获取权重后，放置在从上述下载的模型代码的主目录下，放置后的目录结构应为如下：

      1
      2
      3
      4
      5
      6
      ├── DeepSeek-V3
      │   ├── README.md
      │   └── 权重文件1
      │   .   
      │   .
      │   └── 权重文件n

    • 本地没有模型权重我们提供模型权重下载脚本，支持HuggingFace，ModelScope以及Modelers来源的模型下载，用法如下

      注意：以下引用的atb_models路径在DeepSeek-V2路径下

      1. 确认atb_models/build/weights_url.yaml文件中对应repo_id，当前已默认配置模型官方认可的下载地址，如您有其他信任来源的repo_id，可自行修改，默认配置如下：

        1
        2
        3
        HuggingFace: deepseek-ai/DeepSeek-V3
        ModelScope: deepseek-ai/DeepSeek-V3
        Modelers: None

      2. 执行下载脚本atb_models/build/download_weights.py:

        hub：可选，str类型参数，hub来源，支持HuggingFace, ModelScope, Modelers

        repo_id：可选，str类型参数，仓库ID，默认从weight_url.yaml中读取

        target_dir：可选，str类型参数，默认放置在atb_models同级目录下

    • 修改模型文件夹属组为1001，执行权限为750，执行：

      1
      2
      chown -R 1001:1001 /path-to-weights/DeepSeek-V3
      chmod -R 750 /path-to-weights/DeepSeek-V3

  • 启动容器

    • 执行以下启动命令（参考）：

      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      13
      14
      15
      16
      17
      18
      19
      20
      21
      docker run -itd --privileged  --name=容器名称 --net=host \
         --shm-size 500g \
         --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/hisi_hdc \
         --device /dev/devmm_svm \
         -v /usr/local/Ascend/driver:/usr/local/Ascend/driver \
         -v /usr/local/Ascend/firmware:/usr/local/Ascend/firmware \
         -v /usr/local/sbin/npu-smi:/usr/local/sbin/npu-smi \
         -v /usr/local/sbin:/usr/local/sbin \
         -v /etc/hccn.conf:/etc/hccn.conf \
         -v /权重路径:/权重路径 \
         mindie:1.0.0-XXX-800I-A2-arm64-py3.11（根据加载的镜像名称修改） \
         bash

    • 开启通信环境变量

      1
      2
      3
      4
      5
      export ATB_LLM_HCCL_ENABLE=1
      export ATB_LLM_COMM_BACKEND="hccl"
      export HCCL_CONNECT_TIMEOUT=7200
      export WORLD_SIZE=32
      export HCCL_EXEC_TIMEOUT=0

纯模型测试

前置准备

  • 修改权重目录下config.json文件

    将 model_type 更改为 deepseekv2 (全小写且无空格)

    注意：在本仓实现中，DeepSeek-V3目前沿用DeepSeekV2代码框架

  • 检查机器网络情况

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
      # 检查物理链接
      for i in {0..7}; do hccn_tool -i $i -lldp -g | grep Ifname; done 
      # 检查链接情况
      for i in {0..7}; do hccn_tool -i $i -link -g ; done
      # 检查网络健康情况
      for i in {0..7}; do hccn_tool -i $i -net_health -g ; done
      # 查看侦测ip的配置是否正确
      for i in {0..7}; do hccn_tool -i $i -netdetect -g ; done
      # 查看网关是否配置正确
      for i in {0..7}; do hccn_tool -i $i -gateway -g ; done
      # 检查NPU底层tls校验行为一致性，建议全0
      for i in {0..7}; do hccn_tool -i $i -tls -g ; done | grep switch
      # NPU底层tls校验行为置0操作
      for i in {0..7};do hccn_tool -i $i -tls -s enable 0;done

    - 获取每张卡的ip地址

      ```cmd
      for i in {0..7};do hccn_tool -i $i -ip -g; done

  • 参考如下格式，配置rank_table_file.json，建议参考DeepSeek-R1示例

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    {
       "server_count": "...", # 总节点数
       # server_list中第一个server为主节点
       "server_list": [
          {
             "device": [
                {
                   "device_id": "...", # 当前卡的本机编号，取值范围[0, 本机卡数)
                   "device_ip": "...", # 当前卡的ip地址，可通过hccn_tool命令获取
                   "rank_id": "..." # 当前卡的全局编号，取值范围[0, 总卡数)
                },
                ...
             ],
             "server_id": "...", # 当前节点的ip地址
             "container_ip": "..." # 容器ip地址（服务化部署时需要），若无特殊配置，则与server_id相同
          },
          ...
       ],
       "status": "completed",
       "version": "1.0"
    }

精度测试

  • 进入modeltest路径

    1
    cd /usr/local/Ascend/llm_model/tests/modeltest/

  • 运行测试脚本，参数说明如下：

    1. dataset可选full_BoolQ、full_CEval等，部分数据集需要设置shots
    2. model_name为deepseekv2
    3. weight_dir为模型权重路径
    4. rank_table_file为“前置准备”中配置的rank_table_file.json路径
    5. world_size为总卡数
    6. node_num为当前节点编号，即rank_table_file.json的server_list中顺序确定
    7. rank_id_start为当前节点起始卡号，即rank_table_file.json中当前节点第一张卡的rank_id
    8. master_address为主节点ip地址，即rank_table_file.json的server_list中第一个节点的ip
    1
    2
    # 需在所有机器上同时执行
    bash run.sh pa_bf16 [dataset] ([shots]) [batch_size] [model_name] ([is_chat_model]) [weight_dir] [rank_table_file] [world_size] [node_num] [rank_id_start] [master_address]

    Example: 在DeepSeek-V3跑CEVAl数据集主节点的命令

    1
    2
    bash run.sh pa_bf16 full_CEval 5 16 deepseekv2 /path/to/weights/DeepSeek-V3 /path/to/xxx/ranktable.json 32 4 0 {主节点IP}
    # 0 代表从0号卡开始推理，之后的机器依次从8，16，24

  • 性能测试

    进入modeltest路径

    1
    cd /usr/local/Ascend/llm_model/tests/modeltest/

    运行测试脚本

    1
    2
    # 需在所有机器上同时执行
    bash run.sh pa_bf16 performance [case_pair] [batch_size] [model_name] ([is_chat_model]) [weight_dir] [rank_table_file] [world_size] [node_num] [rank_id_start] [master_address]

    参数含义同“精度测试”

    Example: 在DeepSeek-V3跑性能测试主节点的命令

    1
    2
    bash run.sh pa_bf16 performance [[256,256]] 16 deepseekv2 /path/to/weights/DeepSeek-V3 /path/to/xxx/ranktable.json 32 4 0 {主节点IP}
    # 0 代表从0号卡开始推理，之后的机器依次从8，16，24。

服务化测试

配置服务化环境变量

变量含义：expandable_segments-使能内存池扩展段功能，即虚拟内存特性。更多详情请查看昇腾环境变量参考

1
export PYTORCH_NPU_ALLOC_CONF=expandable_segments:True

服务化需要rank_table_file.json中配置container_ip字段 所有机器的配置应该保持一致，除了环境变量的MIES_CONTAINER_IP为本机ip地址

1
2
export MIES_CONTAINER_IP=容器ip地址
export RANKTABLEFILE=rank_table_file.json路径

修改服务化参数

1
2
cd /usr/local/Ascend/mindie/latest/mindie-service/
vim conf/config.json

修改以下参数

1
2
3
4
5
6
7
8
9
10
"httpsEnabled" : false,
...
"multiNodesInferEnabled" : true, # 开启多机推理
...
# 若不需要安全认证，则将以下两个参数设为false
"interCommTLSEnabled" : false,
"interNodeTLSEnabled" : false,
...
"modelName" : "DeepSeek-V3" # 不影响服务化拉起
"modelWeightPath" : "权重路径",

Example：仅供参考，不保证性能

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
{
    "Version" : "1.0.0",
    "LogConfig" :
    {
        "logLevel" : "Info",
        "logFileSize" : 20,
        "logFileNum" : 20,
        "logPath" : "logs/mindie-server.log"
    },

    "ServerConfig" :
    {
        "ipAddress" : "改成主节点IP",
        "managementIpAddress" : "改成主节点IP",
        "port" : 1025,
        "managementPort" : 1026,
        "metricsPort" : 1027,
        "allowAllZeroIpListening" : false,
        "maxLinkNum" : 1000, //如果是4机，建议300
        "httpsEnabled" : false,
        "fullTextEnabled" : false,
        "tlsCaPath" : "security/ca/",
        "tlsCaFile" : ["ca.pem"],
        "tlsCert" : "security/certs/server.pem",
        "tlsPk" : "security/keys/server.key.pem",
        "tlsPkPwd" : "security/pass/key_pwd.txt",
        "tlsCrlPath" : "security/certs/",
        "tlsCrlFiles" : ["server_crl.pem"],
        "managementTlsCaFile" : ["management_ca.pem"],
        "managementTlsCert" : "security/certs/management/server.pem",
        "managementTlsPk" : "security/keys/management/server.key.pem",
        "managementTlsPkPwd" : "security/pass/management/key_pwd.txt",
        "managementTlsCrlPath" : "security/management/certs/",
        "managementTlsCrlFiles" : ["server_crl.pem"],
        "kmcKsfMaster" : "tools/pmt/master/ksfa",
        "kmcKsfStandby" : "tools/pmt/standby/ksfb",
        "inferMode" : "standard",
        "interCommTLSEnabled" : false,
        "interCommPort" : 1121,
        "interCommTlsCaPath" : "security/grpc/ca/",
        "interCommTlsCaFiles" : ["ca.pem"],
        "interCommTlsCert" : "security/grpc/certs/server.pem",
        "interCommPk" : "security/grpc/keys/server.key.pem",
        "interCommPkPwd" : "security/grpc/pass/key_pwd.txt",
        "interCommTlsCrlPath" : "security/grpc/certs/",
        "interCommTlsCrlFiles" : ["server_crl.pem"],
        "openAiSupport" : "vllm"
    },

    "BackendConfig" : {
        "backendName" : "mindieservice_llm_engine",
        "modelInstanceNumber" : 1,
        "npuDeviceIds" : [[0,1,2,3,4,5,6,7]],
        "tokenizerProcessNumber" : 8,
        "multiNodesInferEnabled" : true,
        "multiNodesInferPort" : 1120,
        "interNodeTLSEnabled" : false,
        "interNodeTlsCaPath" : "security/grpc/ca/",
        "interNodeTlsCaFiles" : ["ca.pem"],
        "interNodeTlsCert" : "security/grpc/certs/server.pem",
        "interNodeTlsPk" : "security/grpc/keys/server.key.pem",
        "interNodeTlsPkPwd" : "security/grpc/pass/mindie_server_key_pwd.txt",
        "interNodeTlsCrlPath" : "security/grpc/certs/",
        "interNodeTlsCrlFiles" : ["server_crl.pem"],
        "interNodeKmcKsfMaster" : "tools/pmt/master/ksfa",
        "interNodeKmcKsfStandby" : "tools/pmt/standby/ksfb",
        "ModelDeployConfig" :
        {
            "maxSeqLen" : 10000,
            "maxInputTokenLen" : 2048,
            "truncation" : true,
            "ModelConfig" : [
                {
                    "modelInstanceType" : "Standard",
                    "modelName" : "DeepSeek-V3",
                    "modelWeightPath" : "/home/data/dsv3_base_step178000",
                    "worldSize" : 8,
                    "cpuMemSize" : 5,
                    "npuMemSize" : -1,
                    "backendType" : "atb",
                    "trustRemoteCode" : false
                }
            ]
        },

        "ScheduleConfig" :
        {
            "templateType" : "Standard",
            "templateName" : "Standard_LLM",
            "cacheBlockSize" : 128,

            "maxPrefillBatchSize" : 8,
            "maxPrefillTokens" : 2048,
            "prefillTimeMsPerReq" : 150,
            "prefillPolicyType" : 0,

            "decodeTimeMsPerReq" : 50,
            "decodePolicyType" : 0,

            "maxBatchSize" : 8,
            "maxIterTimes" : 1024,
            "maxPreemptCount" : 0,
            "supportSelectBatch" : false,
            "maxQueueDelayMicroseconds" : 5000
        }
    }
}

拉起服务化

1
2
3
4
5
6
7
8
# 以下命令需在所有机器上同时执行
# 解决权重加载过慢问题
export OMP_NUM_THREADS=1
# 设置显存比
export NPU_MEMORY_FRACTION=0.95
# 拉起服务化
cd /usr/local/Ascend/mindie/latest/mindie-service/
./bin/mindieservice_daemon

执行命令后，首先会打印本次启动所用的所有参数，然后直到出现以下输出：

1
Daemon start success!

则认为服务成功启动

来到客户端

进入相同容器，向服务端发送请求

更多信息可参考官网信息：MindIE Service

常见问题

  1. 若出现out of memory报错，可适当调高NPU_MEMORY_FRACTION环境变量（默认值为0.8），适当调低服务化配置文件config.json中maxSeqLen、maxInputTokenLen、maxPrefillBatchSize、maxPrefillTokens、maxBatchSize等参数

    1
    export NPU_MEMORY_FRACTION=0.96

  2. 若出现hccl通信超时报错，可配置以下环境变量

    1
    2
    export HCCL_CONNECT_TIMEOUT=7200
    export HCCL_EXEC_TIMEOUT=0

  3. 若出现AttributeError：’IbisTokenizer’ object has no atrribute ‘cache_path’ Step1: 进入环境终端后执行

    1
    pip show mies_tokenizer

    Step1: 默认出现类似如下结果，重点查看Location

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    Name: mies_tokenizer
    Version: 0.0.1
    Summary: ibis tokenizer
    Home-page:
    Author:
    Author-email:
    License:
    Location: /usr/local/python3.10.13/lib/python3.10/site-packages
    Requires:
    Required-by:

    Step2: 打开Location路径下的./mies_tokenizer/tokenizer.py文件

    1
    vim /usr/local/python3.10.13/lib/python3.10/site-packages/mies_tokenizer/tokenizer.py

    Step3: 对以下两个函数代码进行修改

    1
    2
    3
    4
    5
    6
    7
    8
    def __del__(self):
    -       dir_path = file_utils.standardize_path(self.cache_path)
    +       cache_path = getattr(self, 'cache_path', None)
    +       if cache_path is None:
    +           return
    +       dir_path = file_utils.standardize_path(cache_path)
            file_utils.check_path_permission(dir_path)
            all_request = os.listdir(dir_path)

    以及

    1
    2
    3
    4
    5
    6
    7
    8
    def _get_cache_base_path(child_dir_name):
            dir_path = os.getenv("LOCAL_CACHE_DIR", None)
            if dir_path is None:
               dir_path = os.path.expanduser("~/mindie/cache")
    -          if not os.path.exists(dir_path):
    -              os.makedirs(dir_path)
    +          os.makedirs(dir_path, exist_ok=True)
               os.chmod(dir_path, 0o750)

  4. 若出现UnicodeEncodeError: 'ascii' codec can't encode character \uff5c in position 301:ordinal not in range(128)

    这是因为由于系统在写入或打印日志ASCII编码deepseek的词表失败，导致报错，不影响服务化正常运行

    如果需要规避，需要/usr/local/Ascend/atb-models/atb_llm/runner/model_runner.py的第145行注释掉：print_log(rank, logger.info, f’init tokenizer done: {self.tokenizer}’)

    注意保证权重路径是可用的，执行以下命令修改权限，注意是整个父级目录的权限：

    1
    2
    chown -R HwHiAiUser:HwHiAiUser /path-to-weights
    chmod -R 750 /path-to-weights