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

使用方法

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 版本 | 3.9 |
---
## 二、模型加载性能
- 加载耗时：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 基础设施在智能编程领域的应用提供了可靠实践路径。

内容涵盖三大核心环节：

1. 环境配置：通过一键 Shell 脚本自动安装兼容的 PyTorch（2.1.0）与 torch_npu（2.1.0.post3），并验证 NPU 可用性；
2. 模型下载：利用国内 Hugging Face 镜像（hf-mirror.com）高效下载 CodeLlama 模型，避免网络超时问题；
3. 推理与性能测评：通过最小化 Demo 验证推理链路，并运行多场景基准测试脚本，全面评估吞吐量、延迟与显存占用。

关键成果：

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

免责声明

本文所述操作基于特定时间点（2025 年）的软件版本与平台环境，包括但不限于 PyTorch、torch_npu 及 Hugging Face Transformers。由于软硬件生态持续演进，部分内容可能在未来失效或需要调整。

作者不对因复现本文内容而导致的任何系统异常、数据丢失或性能偏差承担责任。建议读者在正式环境中先行充分测试。