昇腾 NPU 部署 Llama 大模型实战指南与常见问题解决

创建后等一分钟左右，实例就启动了，接下来就能进入 Jupyter Notebook 界面操作啦。

3. 环境配置

刚才选的镜像特别贴心，常用工具都给你装好了：

• PyTorch 2.1.0：版本够新，兼容性也不错；
• CANN 8.0：昇腾的核心计算架构，跑模型全靠它；
• Python 3.8：不用自己装环境，直接用就行；
• torch_npu 2.1.0：PyTorch 适配昇腾的关键插件，后面会用到。

三、验证环境

刚进 Notebook，我就迫不及待想验证 NPU 能不能用，结果第一个坑就找上门了。

1. 打开 Terminal

在 Notebook 界面找到'终端'入口，点开就是熟悉的 Linux 命令行。

2. 验证 NPU

先跑两条命令检查版本，都没问题：

# 检查系统版本
cat /etc/os-release
NAME="openEuler"
VERSION="22.03 (LTS-SP3)"
ID="openEuler"
VERSION_ID="22.03"
PRETTY_NAME="openEuler 22.03 (LTS-SP3)"
ANSI_COLOR="0;31"

# 检查 python 版本
python3 --version
Python 3.8.19

# 检查 PyTorch 版本
python -c "import torch; print(f'PyTorch 版本：{torch.__version__}')"
PyTorch 版本：2.1.0

# 检查 torch_npu
python -c "import torch_npu; print(f'torch_npu 版本：{torch_npu.__version__}')"
torch_npu 版本：2.1.0.post3

接着我想验证 NPU 是否可用，直接跑了 python -c "import torch; print(torch.npu.is_available())"，结果报错 AttributeError: module 'torch' has no attribute 'npu'，当时我还以为环境没装好，折腾了半天才发现——必须先导入 torch_npu 插件！正确的命令应该是这样：

# 如果没安装 torch，可以执行安装，咱们是系统自带的
pip install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cpu 

# 正确的写法
python -c "import torch; import torch_npu; print(torch.npu.is_available())"
# 输出：True

看到'True'的时候，我才算松了口气，确认 NPU 能正常用了，而且有 1 个 NPU 设备。后来才发现，这个细节文档里没明说，纯纯是自己踩坑踩出来的经验。

四、安装依赖

环境验证完，以为能直接跑模型了？别着急，还有个关键依赖没装——transformers 库。虽然镜像里有 PyTorch 和 torch_npu，但跑 Llama 大模型必须用这个库，得手动装一下。

直接用清华镜像加速，命令特别简单：

pip install transformers accelerate -i https://pypi.tuna.tsinghua.edu.cn/simple

我当时用了清华源，一会就装好了，要是用默认源，说不定还得等半天，大家记得加上镜像地址，省时间！

五、部署 Llama

终于到了最关键的部署环节，本以为能顺顺利利，结果又踩了好几个坑，还好最后都解决了。

1. 模型下载

一开始我想从 Llama-2 官方仓库 meta-llama/Llama-2-7b-hf 下载，结果发现要申请访问权限，而且国内访问 HuggingFace 经常超时，下载到一半就卡住。

后来才找到解决方案：用开源社区的镜像版本 NousResearch/Llama-2-7b-hf，不用申请权限，下载还稳定，几分钟就搞定了。

2. 创建测试脚本

我本来想在 Terminal 里用 vim 创建脚本，结果报错 sh: vim: command not found，原来 GitCode 环境里没装 vim。其实不用纠结，直接在 Notebook 里新建 Python 文件就行。

# 终端上先执行地址指向
export HF_ENDPOINT=https://hf-mirror.com

3. 核心代码

代码不算复杂，但有两个地方特别容易出错，我都标出来了：

import torch
import torch_npu
from transformers import AutoModelForCausalLM, AutoTokenizer
import time

print("开始测试...")
# 使用开放的 Llama 镜像
MODEL_NAME = "NousResearch/Llama-2-7b-hf"
print(f"下载模型：{MODEL_NAME}")
tokenizer = AutoTokenizer.from_pretrained(MODEL_NAME)
model = AutoModelForCausalLM.from_pretrained(
    MODEL_NAME,
    torch_dtype=torch.float16,
    low_cpu_mem_usage=True
)
print("加载到 NPU...")
model = model.npu()
model.eval()
print(f"显存占用：{torch.npu.memory_allocated()/1e9:.2f} GB")

# 简单测试
prompt = "The capital of France is"
inputs = tokenizer(prompt, return_tensors="pt")
inputs = {k: v.npu() for k, v in inputs.items()}

start = time.time()
outputs = model.generate(**inputs, max_new_tokens=50)
end = time.time()
text = tokenizer.decode(outputs[0])

print(f"\n生成文本：{text}")
print(f"耗时：{(end-start)*1000:.2f}ms")
print(f"吞吐量：{50/(end-start):.2f} tokens/s")

还有个坑要注意：代码里不能写 inputs.npu()，得用 inputs.to('npu:0')，我一开始写错了，报错后才改对，大家别犯同样的错：

# 错误写法（会报 AttributeError）
# inputs = tokenizer(prompt, return_tensors="pt").npu()

# 正确写法
inputs = tokenizer(prompt, return_tensors="pt").to('npu:0')

然后执行上面代码，下载大模型。

# 下载大模型
python llama.py

4. 模型下载过程

模型文件总共约 13GB，分成了两个 shard 文件：model-00001-of-00002.safetensors 和 model-00002-of-00002.safetensors。我当时用镜像版本下载，速度还不错，大概 5 分钟就下完了。加载完成后看了下显存，占用 13.61GB，和 7B 模型在 FP16 精度下的理论大小（约 14GB）差不多，很正常。

六、性能测试

搞定模型下载后，我兴冲冲想测测昇腾 NPU 的实力，结果写测试脚本时又闹了不少笑话 —— 一开始把计时放在 model.generate() 外面，算出的速度快得离谱，还以为昇腾突然'开了挂'，后来才发现是没算预热时间，纯属自欺欺人。

6.1 性能测试

第一次的测试脚本报错，这里就不贴出来了，见下面修改后的完整脚本。

Traceback (most recent call last):
  File "test_llama.py", line 47, in <module>
    result = benchmark(case["输入"], max_new_tokens=100 if case["场景"] != "代码生成" else 150)
  File "test_llama.py", line 7, in benchmark
    inputs = tokenizer(prompt, return_tensors="pt").to("npu:0")
NameError: name 'tokenizer' is not defined

然后经历了 NameError 的暴击后，我痛定思痛重构了测试脚本，不仅解决了变量作用域问题，还加了不少实用细节。现在这套代码亲测能跑，再也不用对着屏幕发呆了——

import torch
import torch_npu
# 千万别漏了这个！
import time
import json
from datetime import datetime
from transformers import AutoModelForCausalLM, AutoTokenizer

# 全局配置（改这里就行，不用动下面的代码）
MODEL_NAME = "NousResearch/Llama-2-7b-hf"  # 模型名称
DEVICE = "npu:0"  # 固定用昇腾 NPU
WARMUP_RUNS = 3  # 预热次数（让 NPU 先'热热身'）
TEST_RUNS = 10  # 正式测试次数（取平均值更靠谱）
SAVE_RESULT = True  # 是否保存结果到 JSON 文件

def load_model_and_tokenizer(model_name):
    """加载模型和 tokenizer 的专用函数，避免重复代码"""
    print(f"正在加载模型 {model_name}...")
    tokenizer = AutoTokenizer.from_pretrained(model_name)
    # 用 FP16 精度加载，省显存还快
    model = AutoModelForCausalLM.from_pretrained(
        model_name,
        torch_dtype=torch.float16,
        low_cpu_mem_usage=True
    ).to(DEVICE)
    model.eval()
    # 切换到推理模式
    print(f"模型已加载到{DEVICE}，显存占用：{torch.npu.memory_allocated()/1e9:.2f}GB")
    return model, tokenizer

def benchmark(prompt, tokenizer, model, max_new_tokens=100):
    """性能测试核心函数，带预热和同步"""
    # 处理输入
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # 预热：第一次运行会编译算子，不算入结果
    print(f"预热中...（{WARMUP_RUNS}次）")
    for _ in range(WARMUP_RUNS):
        with torch.no_grad():
            # 推理时关闭梯度计算，省显存
            _ = model.generate(**inputs, max_new_tokens=max_new_tokens, do_sample=False, pad_token_id=tokenizer.eos_token_id)
    
    # 正式测试
    print(f"开始测试...（{TEST_RUNS}次）")
    latencies = []
    for i in range(TEST_RUNS):
        torch.npu.synchronize()  # 等 NPU 准备好再计时，避免'作弊'
        start_time = time.time()
        with torch.no_grad():
            outputs = model.generate(**inputs, max_new_tokens=max_new_tokens, do_sample=False, pad_token_id=tokenizer.eos_token_id)
        torch.npu.synchronize()  # 等 NPU 算完再停表，确保时间准确
        end_time = time.time()
        latency = end_time - start_time
        latencies.append(latency)
        print(f"第{i+1}次测试：耗时{latency:.2f}秒，速度{max_new_tokens/latency:.2f}tokens/秒")
    
    # 计算统计结果
    avg_latency = sum(latencies)/len(latencies)
    throughput = max_new_tokens / avg_latency
    return {
        "prompt": prompt,
        "max_new_tokens": max_new_tokens,
        "平均延迟 (秒)": round(avg_latency, 2),
        "平均吞吐量 (tokens/秒)": round(throughput, 2),
        "显存占用 (GB)": round(torch.npu.memory_allocated()/1e9, 2)
    }

if __name__ == "__main__":
    # 1. 加载模型和 tokenizer（这步最耗时，耐心等）
    model, tokenizer = load_model_and_tokenizer(MODEL_NAME)
    
    # 2. 定义测试用例（覆盖不同场景）
    test_cases = [
        {"场景": "英文短文本生成", "输入": "The capital of France is", "生成长度": 100},
        {"场景": "中文对话", "输入": "请解释什么是人工智能：", "生成长度": 100},
        {"场景": "代码生成", "输入": "Write a Python function to calculate fibonacci:", "生成长度": 150}
    ]
    
    # 3. 逐个测试并收集结果
    results = []
    for case in test_cases:
        print(f"\n===== 测试场景：{case['场景']} =====")
        result = benchmark(
            prompt=case["输入"],
            tokenizer=tokenizer,  # 显式传参，再也不怕 NameError
            model=model,  # 显式传参，变量作用域清清楚楚
            max_new_tokens=case["生成长度"]
        )
        result["场景"] = case["场景"]  # 补充场景信息
        results.append(result)
        print(f"场景结果：{result}")
    
    # 4. 保存结果（方便后续分析）
    if SAVE_RESULT:
        timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
        filename = f"llama_benchmark_{timestamp}.json"
        with open(filename, "w", encoding="utf-8") as f:
            json.dump(results, f, ensure_ascii=False, indent=2)
        print(f"\n测试结果已保存到 {filename}")
    
    print("\n===== 测试完成 =====")
    print("性能总结：")
    for res in results:
        print(f"{res['场景']}：{res['平均吞吐量 (tokens/秒)']} tokens/秒")

6.2 为啥这套代码靠谱？

1. 变量作用域清清楚楚：把 tokenizer 和 model 作为参数传给 benchmark 函数，再也不会出现 NameError。
2. 细节拉满的测试逻辑：
   • 单独的 load_model_and_tokenizer 函数，避免代码重复
   • 强制 torch.npu.synchronize() 同步计时，结果真实可信
   • 加了 model.eval() 和 with torch.no_grad()，显存占用直降 2GB
   • 自动保存 JSON 结果，带时间戳不怕重名
3. 新手友好的提示信息：运行时会打印每步进度，比如'预热中…（3 次）'、'第 2 次测试：耗时 5.8 秒'，就算出问题也能快速定位在哪一步翻车。

6.3 运行效果参考

我在 GitCode 的昇腾实例上跑出来的结果大概是这样（供参考）：

===== 测试完成 =====
性能总结：
英文短文本生成：16.75 tokens/秒
中文对话：16.58 tokens/秒
代码生成：16.59 tokens/秒

虽然不算顶尖速度，但胜在稳定可靠。最关键的是——这套代码真的不会报 NameError 了！

七、常见问题与解决方案

整个过程中，我踩了不少坑，现在整理出来，大家看完就能避开，不用再走弯路：

坑 1：torch.npu 找不到

• 现象：运行 torch.npu.is_available() 报错 AttributeError: module 'torch' has no attribute 'npu'。
• 原因：torch_npu 是单独的插件，不是 PyTorch 自带的，必须显式导入。
• 解决：在代码开头加一行 import torch_npu，顺序在 import torch 之后就行。

坑 2：tokenizer.npu() 不存在

• 现象：写 inputs = tokenizer(...).npu() 报错，说没有 npu() 方法。
• 原因：tokenizer 返回的是字典类型，字典没有 npu() 这个方法，和 Tensor 不一样。
• 解决：换成 inputs = tokenizer(...).to('npu:0')，用 to() 方法指定设备就行。

坑 3：Llama 下载需要权限

• 现象：访问 meta-llama/Llama-2-7b-hf 被拒绝，提示要申请权限。
• 原因：官方仓库有访问限制，不是所有人都能直接下载。
• 解决：用开源镜像版本 NousResearch/Llama-2-7b-hf，不用申请权限，下载还快。

坑 4：网络超时

• 现象：下载模型到一半卡住，提示 timeout。
• 原因：国内访问 HuggingFace 不稳定，容易断连。
• 解决：要么用国内镜像加速（执行 export HF_ENDPOINT=https://hf-mirror.com），要么用 ModelScope 下载（from modelscope import snapshot_download; model_dir = snapshot_download('shakechen/Llama-2-7b-hf')），两种方法都能解决超时问题。

八、性能优化建议

虽然这次测试的吞吐量不算高，但也不是没办法优化，我总结了三个方向，大家可以试试：

1. 用 mindie 框架

这是昇腾官方出的大模型框架，专门针对昇腾 NPU 做了深度优化，比用原生 transformers 代码快不少，我后面打算试试这个。

2. 试试 INT8 量化

用 INT8 精度加载模型，既能减少显存占用，还能提升速度。代码也不难改，加个量化配置就行：

from transformers import BitsAndBytesConfig
quantization_config = BitsAndBytesConfig(load_in_8bit=True)
model = AutoModelForCausalLM.from_pretrained(
    MODEL_NAME,
    quantization_config=quantization_config
)

理论上能快 20%-30%，显存占用也能降一半，值得尝试。

3. 批处理推理

如果有多个请求，别一个一个处理，用 batch 推理能显著提升吞吐量。比如一次处理 4 个请求：

# batch=4 的例子
prompts = ["prompt1", "prompt2", "prompt3", "prompt4"]
inputs = tokenizer(prompts, return_tensors="pt", padding=True).to('npu:0')
outputs = model.generate(**inputs, max_new_tokens=100)

我这次只测了 batch=1，要是 batch 调大，吞吐量肯定能上去。

九、总结与建议

折腾了这么久，我对昇腾 NPU 也算有了直观的认识，总结几点感受和建议，给想尝试的朋友参考：

昇腾适合这些场景

• 技术层面：部署流程不算复杂，PyTorch 代码改一改就能用，文档和生态比我预期的完善，就是有些细节要注意（比如导入 torch_npu）。
• 适用场景：适合对供应链自主可控有要求的政企项目，预算有限但想跑大模型的团队，还有离线批量推理任务；要是做实时交互式应用，可能需要再优化优化性能。
• 成本效益：云上测试几十块就能验证方案，硬件采购也比 NVIDIA GPU 便宜，综合性价比还不错。

测试总结

• 先云上测试，别盲目买硬件：先在 ModelArts 花几十块试试，或者 GitCode 免费薅个实例，跑通流程再决定要不要买硬件，避免浪费钱。
• 镜像别乱选，认准 NPU+PyTorch：选错镜像会多走很多弯路，就用我前面推荐的那个，省得自己装环境。
• 细节别忽略：import torch_npu 必须加，to('npu:0') 别写成 .npu()，这些小细节错了就会报错。
• 合理预期性能：别指望昇腾能比顶级 NVIDIA GPU 快，但满足日常需求没问题，关键是性价比和自主可控。
• 多逛社区：GitCode 上有很多实际案例，遇到问题先搜一搜，说不定别人早就踩过同样的坑了。

这次测试虽然踩了不少坑，但总体来说很值，真正体验了一把国产 AI 芯片的实力。昇腾的生态确实在慢慢变好，虽然性能还有提升空间，但对于很多场景来说已经够用了。如果你也对国产 AI 芯片感兴趣，不妨试试，说不定会有意外收获！

注：本文内容基于昇腾 NPU 环境实测，仅供参考。