在昇腾 NPU 上部署与测评 CodeLlama-7b-Python

在昇腾 NPU 上部署与测评 CodeLlama-7b-Python

本文记录了在昇腾 NPU 环境中从零开始部署 CodeLlama-7b-Python 模型的全过程，涵盖环境配置、模型加载、推理验证及基础性能评估。所有操作基于支持昇腾 NPU 的计算实例完成，旨在为后续开发者提供一份可复现的参考流程。

一、环境准备：启动合适的计算实例

首先，需要选择一个支持昇腾 NPU 的计算实例。这类实例通常预装了 CANN（Compute Architecture for Neural Networks）工具链和 PyTorch + torch_npu 插件，省去了手动编译驱动的麻烦。

我的操作说明：

启动实例后，我特意确认了运行时是否为 Python 3.9、PyTorch 2.x 的镜像。通过 npu-smi info 命令验证 NPU 设备是否被正确识别——看到设备列表正常输出，心里才踏实下来。

1.1 选择配置并启动实例

在计算平台选择支持 昇腾 NPU 的 Notebook 实例，并启动。

1.2 一键安装 PyTorch + torch_npu（昇腾专用）

创建脚本 install_torch_npu.sh：

#!/bin/bash 
echo "🚀 开始安装 PyTorch + torch_npu（昇腾 NPU 专用）..." 
# 设置国内镜像源（加速后续模型下载） 
export HF_ENDPOINT=https://hf-mirror.com 
export HF_HUB_DOWNLOAD_TIMEOUT=600 
export HF_HUB_SSL_TIMEOUT=60 
# 升级 pip 
python3 -m pip install --upgrade pip -i https://pypi.tuna.tsinghua.edu.cn/simple 
# 安装 PyTorch（CPU 版，NPU 由 torch_npu 提供支持） 
if ! python3 -c "import torch" &> /dev/null; then 
    echo "📦 正在安装 PyTorch 2.1.0..." 
    python3 -m pip install torch==2.1.0 torchvision==0.16.0 torchaudio==2.1.0 \ 
        -i https://pypi.tuna.tsinghua.edu.cn/simple 
fi 
# 安装 torch_npu（必须从华为官方源） 
if ! python3 -c "import torch_npu" &> /dev/null; then 
    echo "📦 正在安装 torch_npu 2.1.0.post3..." 
    python3 -m pip install torch_npu==2.1.0.post3 \ 
        -f https://download.linux.hicloud.com/npu/torch_npu/index.html \ 
        --trusted-host download.linux.hicloud.com 
fi 
# 验证 NPU 
echo "" 
echo "🔍 验证 NPU 设备是否识别..." 
python3 -c " 
import torch 
import torch_npu 
print('PyTorch 版本:', torch.__version__) 
print('torch_npu 版本:', torch_npu.__version__) 
print('NPU 设备数量:', torch.npu.device_count()) 
print('当前设备:', torch.npu.current_device()) 
print('✅ NPU 可用！') 
" 
echo "" 
echo "🎉 安装完成！现在可以运行 CodeLlama 测评脚本了。" 

使用方法

chmod +x install_torch_npu.sh 
bash install_torch_npu.sh 

⚠️ 注意：

• 昇腾 NPU 使用 PyTorch CPU 版 + torch_npu 插件，无需 CUDA。
• 若提示缺少 transformers，运行：

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

二、模型下载（使用 HF 镜像）

由于 Hugging Face 官方服务器位于境外，直接下载大模型在国内常面临速度慢、连接超时甚至完全无法访问的问题。为此，我选择通过 HF-Mirror（hf-mirror.com）这一公益镜像站点进行加速下载。该镜像完整同步了 Hugging Face Hub 的公开模型与数据集，且对 huggingface_hub 库完全兼容，只需简单配置即可无缝切换。

2.1 设置镜像环境变量

在终端中预先设置以下环境变量，可全局引导所有基于 huggingface_hub 的下载请求走镜像源：

export HF_ENDPOINT=https://hf-mirror.com # 指定模型/数据集下载的根地址 
export HF_HUB_DOWNLOAD_TIMEOUT=1200 # 延长单文件下载超时至 20 分钟，避免大文件中断 
export HF_HUB_SSL_TIMEOUT=600 # SSL 握手超时设为 10 分钟，提升弱网稳定性 

2.2 创建下载脚本

为了确保下载过程可控、可中断恢复，并避免软链接带来的路径混乱，我编写了一个简洁的 Python 脚本，使用 snapshot_download 接口进行全量拉取：

from huggingface_hub import snapshot_download 

model_id = "codellama/CodeLlama-7b-Python-hf" 
local_dir = "./CodeLlama-7b-Python" 

snapshot_download( 
    repo_id=model_id, 
    local_dir=local_dir, 
    local_dir_use_symlinks=False, 
    resume_download=True, 
    token=False # 公开模型，无需 Token 
) 
print("✅ 模型下载完成！") 

为什么不用 git lfs？

虽然 Hugging Face 仓库底层基于 Git LFS，但直接使用 git clone 在国内极不稳定，且 LFS 文件常因 CDN 限制无法拉取。而 snapshot_download 通过 HTTP 直连文件，配合镜像源，成功率显著更高。

2.3 执行下载

首先安装必要依赖（建议使用清华源加速）：

pip install huggingface-hub -i https://pypi.tuna.tsinghua.edu.cn/simple 
python download_codellama.py 

💡 CodeLlama-7b-Python 的 FP16 权重总大小约为 14 GB。考虑到临时缓存、解压空间及后续推理所需，建议预留至少 20–25 GB 的可用磁盘空间。若空间紧张，可考虑在 SSD 上操作以提升 I/O 效率。

2.4 目录结构验证

CodeLlama-7b-Python/
├── config.json
├── model-00001-of-00002.safetensors
├── model-00002-of-00002.safetensors
├── model.safetensors.index.json
├── tokenizer.model
└── ...

三、模型测试：从快速验证到多场景推理评估

完成模型下载后，下一步是确认它能否在昇腾 NPU 上正常加载并生成合理代码。我将测试分为两个阶段：快速功能验证（确保基本流程跑通）和 多场景推理评估（观察不同任务下的行为表现）。注意：本次测试聚焦于标准 FP16 推理能力验证，不涉及吞吐量、并发或服务级性能指标。

3.1 快速功能验证：5 行代码跑通首例生成

为快速确认端到端流程是否通畅，我编写了一个极简脚本 test_codellama.py，仅包含模型加载、设备迁移、单次生成三个核心步骤：

import torch 
import torch_npu 
from transformers import AutoTokenizer, AutoModelForCausalLM 

# 加载 tokenizer 和模型（自动从本地缓存或镜像下载） 
tokenizer = AutoTokenizer.from_pretrained("codellama/CodeLlama-7b-Python-hf") 
model = AutoModelForCausalLM.from_pretrained( 
    "codellama/CodeLlama-7b-Python-hf", 
    torch_dtype=torch.float16, 
    low_cpu_mem_usage=True 
).npu().eval() 

# 迁移到 NPU 并设为推理模式 
# 构造提示并生成 
prompt = "# 写一个计算平方的函数\n" 
inputs = tokenizer(prompt, return_tensors="pt").to("npu:0") 
outputs = model.generate(**inputs, max_new_tokens=50, pad_token_id=tokenizer.eos_token_id) 
print(tokenizer.decode(outputs[0], skip_special_tokens=True)) 

📌 为什么强调 .npu()？

虽然 torch.npu.current_device() 更显式，但 .npu() 是 PyTorch NPU 插件提供的便捷方法，会自动使用默认设备（通常为 npu:0），在单卡环境下更简洁。

运行命令

脚本顺利执行，终端输出如下 Python 函数：

看到这短短几行代码正确生成的那一刻，心里一块石头落地——说明从环境配置、模型加载到 NPU 推理链路完全打通。虽然只是最简单的例子，但它是后续一切复杂测试的基础。

export HF_ENDPOINT=https://hf-mirror.com 
python test_codellama.py 

3.2 完整性能测评

核心配置

MODEL_NAME = "codellama/CodeLlama-7b-Python-hf" 
DEVICE = "npu:0" 
WARMUP_RUNS = 5 
TEST_RUNS = 10 
PRECISION = "fp16" # 或 "fp32" 
MAX_INPUT_LENGTH = 512 

TEST_CASES = [ 
    {"场景": "函数实现", "输入": "# 写一个快速排序函数\n", "生成长度": 80, "batch_size": 1}, 
    {"场景": "单元测试", "输入": "# 为上述函数编写 pytest 测试用例\n", "生成长度": 100, "batch_size": 1}, 
    {"场景": "API 调用", "输入": "# 使用 requests 获取 GitHub 用户信息\n", "生成长度": 90, "batch_size": 1}, 
    {"场景": "装饰器", "输入": "# 写一个装饰器记录函数执行时间\n", "生成长度": 70, "batch_size": 2}, 
    {"场景": "列表推导", "输入": "# 用列表推导式过滤偶数\n", "生成长度": 50, "batch_size": 4}, 
    {"场景": "异常处理", "输入": "# 编写带 try-except 的文件读取函数\n", "生成长度": 85, "batch_size": 1}, 
] 

模型加载（自动修复 pad_token）

def load_model_and_tokenizer(model_name, precision): 
    tokenizer = AutoTokenizer.from_pretrained(model_name, trust_remote_code=True) 
    if tokenizer.pad_token_id is None: 
        tokenizer.pad_token_id = tokenizer.eos_token_id 
    dtype = torch.float16 if precision == "fp16" else torch.float32 
    model = AutoModelForCausalLM.from_pretrained( 
        model_name, 
        torch_dtype=dtype, 
        low_cpu_mem_usage=True, 
        trust_remote_code=True 
    ).to(DEVICE).eval() 
    mem_used = torch.npu.memory_allocated(DEVICE) / 1e9 
    return model, tokenizer, mem_used 

性能基准测试函数

def benchmark(prompt, tokenizer, model, max_new_tokens, batch_size): 
    inputs = tokenizer( 
        [prompt] * batch_size, 
        return_tensors="pt", 
        padding=True, 
        truncation=True, 
        max_length=MAX_INPUT_LENGTH, 
        return_attention_mask=True 
    ).to(DEVICE) 
    
    # 预热 
    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.pad_token_id, num_beams=1) 
    
    # 正式测试 
    latencies = [] 
    torch.npu.reset_max_memory_allocated(DEVICE) 
    for _ in range(TEST_RUNS): 
        torch.npu.synchronize() 
        start = time.time() 
        with torch.no_grad(): 
            model.generate(**inputs, max_new_tokens=max_new_tokens, do_sample=False, pad_token_id=tokenizer.pad_token_id, num_beams=1) 
        torch.npu.synchronize() 
        latencies.append(time.time() - start) 
    
    avg_latency = sum(latencies) / len(latencies) 
    throughput_per_req = max_new_tokens / avg_latency 
    total_throughput = throughput_per_req * batch_size 
    mem_peak = torch.npu.max_memory_allocated(DEVICE) / 1e9 
    
    return { 
        "平均延迟 (秒)": round(avg_latency, 3), 
        "显存峰值 (GB)": round(mem_peak, 2), 
        "batch_size": batch_size, 
        "生成长度": max_new_tokens 
    } 

主流程（加载 + 多场景测试 + 保存）

if __name__ == "__main__": 
    import os 
    os.environ["HF_ENDPOINT"] = "https://hf-mirror.com" 
    # 加载模型 
    model, tokenizer, _ = load_model_and_tokenizer(MODEL_NAME, PRECISION) 
    
    # 执行测试 
    results = [] 
    for case in TEST_CASES: 
        res = benchmark( 
            prompt=case["输入"], 
            tokenizer=tokenizer, 
            model=model, 
            max_new_tokens=case["生成长度"], 
            batch_size=case["batch_size"] 
        ) 
        res.update({"场景": case["场景"]}) 
        results.append(res) 
    
    # 保存结果（JSON + Markdown） 
    timestamp = datetime.now().strftime("%Y%m%d_%H%M%S") 
    with open(f"codellama_npu_benchmark_fp16_{timestamp}.json", "w") as f: 
        json.dump(results, f, indent=2, ensure_ascii=False) 

运行完整基准测试脚本：

python test_codellama_benchmark.py 

脚本功能：

• 支持 6 种代码生成场景（函数、单元测试、API、装饰器等）
• 自动预热 + 多轮测试
• 输出吞吐量、延迟、显存占用
• 生成 JSON 和 Markdown 报告

四、测试结果汇总

本次基于昇腾 NPU 的 CodeLlama-7b-Python-hf 模型推理测试验证了昇腾硬件在代码生成大模型场景的适配性：在 FP16 精度、PyTorch 2.1.0+torch_npu 2.1.0.post3 环境下，通过批量推理、推理策略调优等轻量化优化手段，可在显存占用可控（峰值＜14GB）的前提下实现 3.8 倍吞吐提升，且推理稳定性不受任务类型影响。建议生产部署时优先落地批量推理 + 预热机制，结合上下文长度管控，可在保证代码生成质量的基础上，最大化昇腾 NPU 的推理效能。

五、附录

5.1 输出文件

测试完成后生成两个文件：

• codellama_npu_benchmark_fp16_20251210_102935.json：原始性能数据
• codellama_npu_benchmark_summary_fp16_20251210_102935.md：Markdown 格式报告

# CodeLlama-7b-Python 在昇腾 NPU 上的性能测试报告 
## 测试时间：2025-12-10 10:29:35 
--- 
## 一、测试环境信息 
| 环境项 | 详情 | 
|------------------|-------------------------------| 
| NPU 设备 | npu:0 | 
| 模型名称 | codellama/CodeLlama-7b-Python-hf | 
| 模型精度 | torch.float16（配置：fp16） | 
| PyTorch 版本 | 2.1.0 | 
| torch_npu 版本 | 2.1.0.post3 | 
| transformers 版本 | 4.46.3| 
| Python 版本 | 2.0.x | 
--- 
## 二、模型加载性能 
- 加载耗时：52.68 秒 
- 加载显存占用：13.48 GB 
- 推理显存峰值范围：13.57 ~ 13.66 GB 
--- 
## 三、各场景性能明细 
场景 batch_size 生成长度 单请求吞吐量 (tokens/秒) 批量总吞吐量 (tokens/秒) 平均延迟 (秒) 延迟标准差 (秒) 显存峰值 (GB) 
函数实现 1 80 17.54 17.54 4.560 0.142 13.57 
单元测试 1 100 17.34 17.34 5.766 0.058 13.58 
API 调用 1 90 17.80 17.80 5.056 0.109 13.57 
装饰器 2 70 17.29 34.58 4.048 0.085 13.65 
列表推导 4 50 17.43 69.71 2.869 0.055 13.66 
异常处理 1 85 17.22 17.22 4.938 0.056 13.57 
--- 
## 四、性能分析与结论 
### 1. 代码任务类型影响 
- 函数实现（80 token）：17.54 tokens/秒 
- 单元测试（100 token）：17.34 tokens/秒 
✅ 结论：不同代码生成任务吞吐波动 < 2%，NPU 支持稳定。 
### 2. 批量并发效率 
- batch=2 总吞吐：34.58 tokens/秒（≈2.0×单请求） 
- batch=4 总吞吐：69.71 tokens/秒（≈3.8×单请求） 
✅ 结论：接近线性加速，适合高并发代码生成服务。 
### 3. 显存与部署建议 
- 峰值显存：13.66 GB（batch=4 时） 
✅ 建议：生产环境使用 ≥16GB 显存的昇腾 NPU。 
--- 
## 五、优化建议 
1. **优先启用 batch 推理**：batch=2~4 可显著提升吞吐。 
2. **关闭采样（do_sample=False）**：保证代码确定性，提升速度。 
3. **避免超长上下文**：输入 + 输出总长度建议 ≤1024 tokens。 
4. **服务启动预热**：前 5 次推理用于算子编译，不计入性能统计。 
--- 
## 六、测试结果文件 
原始数据已保存至： 
- `codellama_npu_benchmark_fp16_20251210_102935.json` 
- `codellama_npu_benchmark_summary_fp16_20251210_102935.md` 

5.2 常见警告说明

• [W VariableFallbackKernel.cpp:51] Warning: CAUTION: The operator 'aten::isin.Tensor_Tensor_out' is not currently supported on the NPU backend… 原因：transformers 内部调用了 NPU 未支持的 torch.isin。
• 影响：极轻微（仅在 token 过滤阶段 fallback 到 CPU）。
• 结论：可安全忽略，不影响主推理流程。

总结

昇腾 NPU 已能良好支持 CodeLlama 等开源大模型的本地化部署与高并发推理，为国产 AI 基础设施在智能编程领域的应用提供了可靠实践路径。

关键成果：

• 模型在 FP16 精度下稳定运行，单请求生成速度达 ~17.5 tokens/s；
• 启用批处理（batch=4）后总吞吐提升至 69.71 tokens/s，接近线性加速；
• 峰值显存仅 13.66 GB，证明昇腾 NPU 具备高效运行 7B 级代码大模型的能力。

注意事项：

本文所述操作基于特定时间点的软件版本与平台环境，包括但不限于 PyTorch、torch_npu 及 Hugging Face Transformers。由于软硬件生态持续演进，部分内容可能在未来失效或需要调整。建议读者在正式环境中先行充分测试。