昇腾 NPU 实战指南：部署与推理 CodeLlama

昇腾 NPU 实战指南：部署与推理 CodeLlama

随着大模型技术在软件开发领域的深入应用，越来越多的开发者开始尝试在本地或云端环境部署代码生成模型。华为昇腾（Ascend）计算产业随着 CANN 软件栈的不断成熟，已成为运行各类开源 LLM 的重要算力底座。

本文将结合云端 Notebook 提供的在线开发环境，讲解如何在昇腾 NPU 环境中完成从依赖配置、模型加载到代码生成的完整流程。通过结构化的流程讲解与可操作的示例代码，引导你在昇腾生态中顺利完成 CodeLlama 的部署与运行。

1. 环境准备

进入云端 Notebook 后，第一件事不是急着写代码，而是检查底层的 NPU 状态和软件栈版本。打开 Terminal，输入以下命令确认芯片健康及显存占用情况：

# 查看 NPU 状态
npu-smi info

![NPU 状态检查输出]

从输出结果中我们能够明确看到版本号，以及功耗和温度等信息，确保 NPU 处于正常状态。

接下来进行基础环境检查：

查看系统版本信息：

cat /etc/os-release

![系统版本信息]

检查 Python 环境：

python3 --version
python -c "import torch; print('PyTorch 版本:', torch.__version__)"
python -c "import torch_npu; print('torch_npu 版本:', torch_npu.__version__)"

![Python 环境检查]

当基础环境准备就绪后，参考 CANN 官网快速入门资料，安装必要的依赖库：

pip3 install attrs cython 'numpy>=1.19.2,<=1.24.0' decorator sympy cffi pyyaml pathlib2 psutil protobuf==3.20.0 scipy requests absl-py --user

![依赖安装完成]

2. 模型选择与加载

本次实战选用 CodeLlama 7B-Instruct。它参数量适中，既能体现推理性能，又不会因为显存不足导致无法运行，非常适合用来做 NPU 性能实测。

加载 Tokenizer

为了将输入文本转换为模型可处理的 token，首先加载 tokenizer：

from transformers import AutoTokenizer

model_name = "code-llama-7b-instruct"
tokenizer = AutoTokenizer.from_pretrained(model_name)

加载模型到 NPU

将模型加载到昇腾 NPU，并设置 FP16 精度以降低显存占用。device_map="auto" 会自动把模型分配到可用的 NPU 上，同时 FP16 精度可以在保证计算精度的前提下降低显存使用。

from transformers import AutoModelForCausalLM
import torch

model = AutoModelForCausalLM.from_pretrained(
    model_name,
    device_map="auto",
    torch_dtype=torch.float16
)

验证加载成功

我们可以简单测试一次推理来验证模型是否已正确加载到 NPU：

import torch_npu
from transformers import AutoTokenizer, AutoModelForCausalLM

model_name = "code-llama-7b-instruct"
tokenizer = AutoTokenizer.from_pretrained(model_name)
model = AutoModelForCausalLM.from_pretrained(
    model_name,
    device_map="auto",
    torch_dtype=torch.float16
)

# 验证模型是否在 NPU 上
device = next(model.parameters()).device
print(f"模型已加载，当前设备：{device}")

# 测试一次简单推理
prompt = "def fibonacci(n):"
inputs = tokenizer(prompt, return_tensors="pt").to(device)
outputs = model.generate(**inputs, max_new_tokens=10)
generated_text = tokenizer.decode(outputs[0], skip_special_tokens=True)
print("生成结果:", generated_text)

![模型加载验证结果]

3. 基础推理演示

在完成模型加载后，我们开始进行 CodeLlama 的基础推理实验，展示 NPU 的实战效果。

单条 Prompt 生成

先尝试最基础的单条 prompt 生成：

from transformers import AutoTokenizer, AutoModelForCausalLM

model_name = "code-llama-7b-instruct"
tokenizer = AutoTokenizer.from_pretrained(model_name)
model = AutoModelForCausalLM.from_pretrained(
    model_name,
    device_map="auto",
    torch_dtype=torch.float16
)

prompt = "def fibonacci(n):"
inputs = tokenizer(prompt, return_tensors="pt").to(next(model.parameters()).device)
outputs = model.generate(**inputs, max_new_tokens=50)
generated_text = tokenizer.decode(outputs[0], skip_special_tokens=True)
print("生成结果:\n", generated_text)

![单条 Prompt 生成结果]

批量推理

在实际场景中，我们经常需要同时处理多条请求，可以尝试批量推理：

prompts = [
    "def factorial(n):",
    "def quicksort(arr):",
    "def gcd(a, b):"
]

inputs = tokenizer(prompts, return_tensors="pt", padding=True).to(next(model.parameters()).device)
outputs = model.generate(**inputs, max_new_tokens=50)

for i, output in enumerate(outputs):
    text = tokenizer.decode(output, skip_special_tokens=True)
    print(f"\nPrompt {i+1} 生成结果:\n{text}")

![批量推理结果]

控制生成风格和长度

还可以通过调整生成参数优化结果，例如控制随机性和采样策略：

outputs = model.generate(
    **inputs,
    max_new_tokens=100,
    temperature=0.7,
    top_p=0.9,
    do_sample=True
)

for i, output in enumerate(outputs):
    text = tokenizer.decode(output, skip_special_tokens=True)
    print(f"\nPrompt {i+1} 生成结果 (控制风格):\n{text}")

![参数控制结果]

多轮对话推理

在实际开发中，模型经常用于多轮交互。下面是一个简单的多轮对话式推理案例：

conversation = ["# 请写一个 Python 函数计算平方根"]

for i in range(2):
    inputs = tokenizer(conversation, return_tensors="pt", padding=True).to(next(model.parameters()).device)
    outputs = model.generate(**inputs, max_new_tokens=50)
    reply = tokenizer.decode(outputs[0], skip_special_tokens=True)
    print(f"\n第 {i+1} 轮生成:\n{reply}")
    conversation.append(reply)

![多轮对话结果]

4. 性能测试

对 CodeLlama 的推理性能进行评估时，我们使用了一个包含多个 Python 函数的 prompt 列表，通过批量输入测量模型生成结果的延迟和吞吐量。每次生成的最大 token 数设置为 50，模拟常见的代码生成场景。

import time
from transformers import AutoTokenizer, AutoModelForCausalLM

model_name = "code-llama-7b-instruct"
tokenizer = AutoTokenizer.from_pretrained(model_name)
model = AutoModelForCausalLM.from_pretrained(
    model_name,
    device_map="auto",
    torch_dtype=torch.float16
)

prompts = [
    "def fibonacci(n):",
    "def factorial(n):",
    "def quicksort(arr):",
    "def gcd(a, b):",
    "def is_prime(n):"
]

inputs = tokenizer(prompts, return_tensors="pt", padding=True).to(next(model.parameters()).device)
num_trials = 5
total_time = 0.0

for i in range(num_trials):
    start_time = time.time()
    outputs = model.generate(**inputs, max_new_tokens=50)
    end_time = time.time()
    elapsed = end_time - start_time
    total_time += elapsed
    print(f"Trial {i+1}: {elapsed:.3f} s")

avg_time = total_time / num_trials
num_tokens = sum(len(tokenizer.decode(output, skip_special_tokens=True)) for output in outputs)
throughput = num_tokens / avg_time

print(f"\n平均延迟：{avg_time:.3f} s")
print(f"吞吐量：{throughput:.1f} 字符/s")

![性能测试结果]

从实际测试结果来看，CodeLlama 在昇腾 NPU 上的单次生成延迟稳定在几十毫秒级别，平均延迟约 0.110 秒；同时还能达到 4727.2 字符/秒的较高吞吐量，足以支撑多 prompt 并行处理的场景需求。

5. 总结

在昇腾 NPU 环境中部署 CodeLlama 并不复杂。云端 Notebook 提供了即开即用的环境，无需依赖本地硬件或复杂配置。整体来看，昇腾已经能够比较稳定地承载主流代码生成模型的推理任务，显著降低了上手门槛，让开发者能够更多地专注于模型本身，而非环境搭建。