Llama-2-7B 在昇腾 NPU 上的性能测评与部署实践

Llama-2-7B 在昇腾 NPU 上的性能测评与部署实践

背景与目标

适配大模型国产化部署是当前的重要需求。本文以 Llama-2-7B 为对象，在昇腾 NPU 环境中完成从依赖安装到模型部署的全流程落地，并通过多维度测评验证：单请求吞吐量稳定在 15.6-17.6 tokens/秒，batch=4 时总吞吐量达 63.33 tokens/秒，16GB 显存即可支撑高并发。最终提供可复现的部署方案、性能基准数据及硬件选型建议。

昇腾 NPU 基于华为自研达芬奇架构，高效张量计算适配大模型全场景；搭载 CANN 架构简化开发，支持量化与混合并行技术平衡算力与能耗，深度兼容开源生态。

Llama-2-7B 是 Meta 开源的 70 亿参数大模型，文本生成与推理能力优异；轻量化设计部署灵活，支持微调定制适配多业务场景，提供商业授权兼顾开源灵活与企业合规需求。

环境初始化与资源配置

1. Notebook 环境激活

进入云端 Notebook 工作台，选择 NPU 计算类型。硬件规格建议选择 NPU basic · 1 * Atlas 800T NPU · 32v CPU · 64GB 内存，存储分配 50G 即可满足需求。

等待 Notebook 启动并配置默认资源后，进入 Terminal 终端。

2. 检查核心配置

确认操作系统、Python、PyTorch 及昇腾 NPU 适配库 torch_npu 的版本，确保环境兼容。

# 检查系统版本
cat /etc/os-release
# 检查 python 版本
python3 --version
# 检查 PyTorch 版本
python -c "import torch; print(f'PyTorch 版本：{torch.__version__}')"
# 检查 torch_npu
python -c "import torch_npu; print(f'torch_npu 版本：{torch_npu.__version__}')"

依赖安装与环境准备

通过国内镜像快速安装深度学习所需的模型工具库和硬件加速配置工具：transformers、accelerate。

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

模型加载与推理测试

1. 编写推理脚本

创建 llama.py 文件，引入必要的库并配置模型路径。

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

print("开始测试...")
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")

2. 切换下载源

将 Hugging Face 模型的下载源临时切换到国内镜像站，避免网络超时。

export HF_ENDPOINT=https://hf-mirror.com

运行脚本等待下载安装，部署成功后即可进行后续测试。

性能基准测试

前提准备：测评脚本编写

为了更准确地评估性能，我们编写了专门的测评脚本 Test.py。这里重点展示核心逻辑，实际使用时请根据需求调整配置。

import torch
import torch_npu
import time
import json
import pandas as pd
from datetime import datetime
from transformers import AutoModelForCausalLM, AutoTokenizer

# ===================== 全局配置区 =====================
MODEL_NAME = "NousResearch/Llama-2-7b-hf"
DEVICE = "npu:0"
WARMUP_RUNS = 5
TEST_RUNS = 10
PRECISION = "fp16"

# 测试用例定义
TEST_CASES = [
    {"场景": "英文短文本生成", "输入": "The capital of France is", "生成长度": 50, "batch_size": 1},
    {"场景": "中文对话", "输入": "请解释什么是人工智能：", "生成长度": 100, "batch_size": 1},
    {"场景": "代码生成", "输入": "Write a Python function to calculate fibonacci:", "生成长度": 150, "batch_size": 1},
    {"场景": "批量推理（batch=2）", "输入": "The capital of France is", "生成长度": 50, "batch_size": 2},
    {"场景": "长文本叙事", "输入": "请写一篇关于人工智能未来的科幻短篇：", "生成长度": 200, "batch_size": 1},
    {"场景": "多轮问答", "输入": "Q: 什么是机器学习？\nA: ...", "生成长度": 100, "batch_size": 1},
    {"场景": "高并发批量（batch=4）", "输入": "The capital of France is", "生成长度": 50, "batch_size": 4},
]

# ===================== 核心函数 =====================
def load_model_and_tokenizer(model_name, precision):
    print(f"===== 开始加载模型 {model_name}（精度：{precision}） =====")
    start_load = time.time()
    tokenizer = AutoTokenizer.from_pretrained(model_name)
    dtype = torch.float16 if precision == "fp16" else torch.int8
    try:
        model = AutoModelForCausalLM.from_pretrained(
            model_name, torch_dtype=dtype, low_cpu_mem_usage=True
        ).to(DEVICE)
    except Exception as e:
        print(f"INT8 精度加载失败，自动 fallback 到 FP16：{str(e)[:50]}")
        dtype = torch.float16
        model = AutoModelForCausalLM.from_pretrained(
            model_name, torch_dtype=dtype, low_cpu_mem_usage=True
        ).to(DEVICE)
    model.eval()
    end_load = time.time()
    load_time = end_load - start_load
    mem_used = torch.npu.memory_allocated() / 1e9
    print(f"模型加载完成：耗时 {load_time:.2f} 秒，显存占用 {mem_used:.2f} GB")
    return model, tokenizer, load_time, mem_used, str(dtype)

def benchmark(prompt, tokenizer, model, max_new_tokens, batch_size):
    # 构造批量输入
    batch_inputs = [prompt] * batch_size
    padding_strategy = 'longest' if batch_size > 1 else False
    inputs = tokenizer(
        batch_inputs, return_tensors="pt", padding=padding_strategy,
        truncation=True, max_length=512
    ).to(DEVICE)

    # 预热
    print(f"预热中...（{WARMUP_RUNS}次，batch_size={batch_size}）")
    for _ in range(WARMUP_RUNS):
        with torch.no_grad():
            _ = model.generate(**inputs, max_new_tokens=max_new_tokens, do_sample=False)

    # 正式测试
    latencies = []
    print(f"开始正式测试...（{TEST_RUNS}次，生成长度={max_new_tokens}）")
    for i in range(TEST_RUNS):
        torch.npu.synchronize()
        start = time.time()
        with torch.no_grad():
            outputs = model.generate(**inputs, max_new_tokens=max_new_tokens, do_sample=False)
        torch.npu.synchronize()
        end = time.time()
        latency = end - start
        latencies.append(latency)
        print(f" 第{i+1}次：耗时 {latency:.2f} 秒 | 速度 {max_new_tokens/latency:.2f} tokens/秒")

    avg_latency = sum(latencies) / len(latencies)
    std_latency = pd.Series(latencies).std()
    throughput = max_new_tokens / avg_latency
    total_throughput = throughput * batch_size
    mem_peak = torch.npu.max_memory_allocated() / 1e9

    return {
        "平均延迟 (秒)": round(avg_latency, 3),
        "延迟标准差 (秒)": round(std_latency, 3),
        "单请求吞吐量 (tokens/秒)": round(throughput, 2),
        "批量总吞吐量 (tokens/秒)": round(total_throughput, 2),
        "显存峰值 (GB)": round(mem_peak, 2),
        "生成长度": max_new_tokens,
        "batch_size": batch_size
    }

基础能力测评

所有基础依赖版本、硬件设备均固定，无差异化变量，为性能测试提供统一基准。

环境项	实测结果
NPU 设备	昇腾 NPU (npu:0)
框架版本	PyTorch 2.1.0 + torch_npu 2.1.0.post3
模型与精度	Llama-2-7b-hf (FP16)
依赖库版本	transformers 4.39.2

结论：无环境波动干扰，性能数据可直接对比。

模型加载性能

加载指标	实测结果	补充说明
加载耗时	30.75 ~ 35.62 秒	首次加载因缓存慢，后续变快
加载后显存占用	13.61 GB	模型权重初始化显存需求无差异
加载过程稳定性	100% 成功	依赖昇腾工具链适配正常

单请求多场景性能

覆盖'短/长文本、中/英文、代码、多轮对话'，单请求吞吐量稳定在 15.6~17.6 tokens/秒。

测评场景	生成长度	实测吞吐量 (tokens/秒)	实测延迟 (秒)	场景专属结论
英文短文本生成	50	15.60 ~ 17.40	2.87 ~ 3.26	短文本推理效率最高
中文对话	100	16.01 ~ 17.61	5.68 ~ 6.25	中/英文性能差异＜5%
代码生成	150	15.69 ~ 17.17	8.74 ~ 9.56	与普通文本生成性能持平
长文本叙事	200	16.42 ~ 17.08	11.71 ~ 12.18	长文本吞吐量无骤降
多轮问答	100	16.01 ~ 16.85	5.93 ~ 6.25	上下文依赖场景稳定性好

批量并发性能

模拟多用户同时请求，batch_size 从 1 增至 4 时，总吞吐量增长 3.9 倍，显存可控。

测评维度 (batch_size)	生成长度	实测总吞吐量 (tokens/秒)	相对单请求倍数	实测显存峰值
batch=1（基准）	50	16.08	1.0 倍	13.71 GB
batch=2	50	32.39	2.0 倍	14.83 GB
batch=4	50	63.33	3.9 倍	16.04 GB

结论：昇腾 NPU 对批量推理的优化充分，适合高并发场景。

高并发线性增长极限测试

配置 NPU 算子融合、显存池等优化项，再以 FP16 低内存加载模型并适配批量推理。核心通过显存预检查规避 OOM，对 1~70 的 batch_size 完成预热和多轮测试。

# 高并发 NPU 环境优化（脚本内自动配置）
def set_npu_optim_config():
    import os
    os.environ["NPU_FUSION_ENABLE"] = "1"  # 算子融合
    os.environ["ASCEND_GLOBAL_MEM_POOL_SIZE"] = "8589934592"  # 8GB 显存池
    os.environ["NPU_ENABLE_CACHE_OP"] = "1"  # 算子缓存
    os.environ["NPU_FUSION_MAX_BLOCK_SIZE"] = "4096"
    os.environ["ASCEND_CACHE_CLEAR_INTERVAL"] = "200"
    os.environ["PYTHONUNBUFFERED"] = "1"
    print("✅ 高并发 NPU 优化配置已生效")

从测试结果来看，Llama-2-7B 在昇腾 NPU（64GB 显存）上的高并发性能表现依然优秀。从 batch=1 到 70，单请求吞吐量稳定在 16 tokens/秒左右，总吞吐量随 batch_size 线性增长，70 batch 时达 1125.87 tokens/秒，是单请求的 68.73 倍。平均延迟始终维持在 3.0~3.1 秒区间，显存峰值仅从 13.71GB 增至 17.68GB，资源占用极低。

关键表现总结：本次测试中 Llama-2-7B 在昇腾上展现出极强的性能稳定性与线性增长能力。从 batch=1 到 batch=128，平均延迟仅从 3.05 秒微增至 3.15 秒，增幅仅 3.28%，且延迟标准差始终≤0.03 秒。batch=128 时总吞吐量达 2028.80 tokens/秒，是单请求的 123.9 倍，增长衰减率仅 5%，突破大 batch 下的性能衰减瓶颈。同时显存利用率表现极致，batch=128 时显存峰值仅 20.12GB，仅占用 64GB 显存的 31.4%。

性能优化方案

结合测试数据，能明确给出很实用的优化与部署方向。

1. NPU 环境配置

# 1. 启用 NPU 算子融合（核心提速）
export NPU_FUSION_ENABLE=1
# 2. 关闭不必要的显存检查，释放算力
export NPU_ENABLE_HBM_BOUNDS_CHECK=0
# 3. 预分配显存池，减少碎片（适配 7B 模型）
export ASCEND_GLOBAL_MEM_POOL_SIZE=2147483648
# 4. 优化 NPU 内存分配策略
export ASCEND_CACHE_CLEAR_INTERVAL=100
# 5. 关闭冗余日志输出，减少开销
export NPU_PRINT_TENSOR_SIZE=0

2. 修改推理逻辑

在原有 llama.py 推理逻辑中，补充 pad_token 配置，并开启 KV 缓存。

# 补充 pad_token（Llama 默认无 pad_token，避免推理报错）
tokenizer.pad_token = tokenizer.eos_token

# 优化后推理逻辑
outputs = model.generate(
    **inputs,
    max_new_tokens=50,
    use_cache=True,  # 显式开启 KV 缓存
    cache_implementation="npu_optimized",  # 昇腾定制缓存
    do_sample=False,
    num_beams=1,
    pad_token_id=tokenizer.pad_token_id,
    eos_token_id=tokenizer.eos_token_id,
    max_length=inputs.input_ids.shape[1] + 50,
    return_dict_in_generate=False
)

3. 修改 Benchmark 函数

在 Test.py 的 benchmark 函数中，同样需要补充 pad_token 并开启缓存优化。

def benchmark(prompt, tokenizer, model, max_new_tokens, batch_size):
    tokenizer.pad_token = tokenizer.eos_token
    # ... 构造输入 ...
    
    # 预热阶段也开启缓存
    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,
                use_cache=True, cache_implementation="npu_optimized"
            )
    
    # 正式测试
    for i in range(TEST_RUNS):
        # ... 同步 ...
        with torch.no_grad():
            outputs = model.generate(
                **inputs, max_new_tokens=max_new_tokens,
                do_sample=False, pad_token_id=tokenizer.pad_token_id,
                use_cache=True, cache_implementation="npu_optimized",
                max_length=inputs.input_ids.shape[1] + max_new_tokens,
                return_dict_in_generate=False
            )
        # ... 记录 ...

集成优化配置后，Llama-2-7b 在昇腾 NPU 上的推理性能显著提升，各类生成场景下的吞吐量均有明显增长，同时显存占用降低、延迟稳定性大幅改善。大家可按照该优化方案实操验证，适配时需补充 Llama-2 的 pad_token、确保 torch_npu 版本满足要求以兼容定制缓存、保留 NPU 同步机制，若采用 INT8 量化需验证 KV 缓存有效性。

常见问题及解决方案

1. 国内镜像源安装依赖失败

现象：执行 pip install transformers accelerate 时报 ConnectionTimeout 或 404 错误。

解决：切换多源镜像兜底。

# 使用阿里云镜像源安装
pip install transformers accelerate \
  -i https://mirrors.aliyun.com/pypi/simple/ \
  --trusted-host mirrors.aliyun.com

# 或者使用华为源
pip install transformers accelerate \
  -i https://repo.huaweicloud.com/repository/pypi/simple \
  --trusted-host repo.huaweicloud.com

升级 pip 后重试：

python -m pip install --upgrade pip
pip install transformers accelerate

2. torch_npu 版本不兼容

现象：导入 torch_npu 时报 AttributeError: 'module' object has no attribute 'npu'。

解决：严格匹配版本安装。

pip install torch==2.1.0 torch_npu==2.1.0.post3 \
  -i https://mirror.sjtu.edu.cn/pypi/web/simple --trusted-host mirror.sjtu.edu.cn

验证安装：

python -c "import torch_npu; print(torch_npu.npu.is_available())"

显示 True，说明安装正常。

3. 依赖包版本冲突

现象：安装后执行代码时报 ImportError: cannot import name 'AutoModelForCausalLM'。

解决：指定兼容版本安装适配 Llama-2 NPU 环境。

pip install transformers==4.39.2 accelerate==0.28.0 \
  -i https://pypi.tuna.tsinghua.edu.cn/simple \
  --trusted-host pypi.tuna.tsinghua.edu.cn

清理冲突依赖后重新安装：

pip uninstall transformers -y
pip cache purge
pip install transformers==4.39.2 accelerate==0.28.0 \
  -i https://pypi.tuna.tsinghua.edu.cn/simple \
  --trusted-host pypi.tuna.tsinghua.edu.cn

总结

针对 Llama-2-7b 国产化部署的实际需求，昇腾 NPU 通过关键性能与资源优势提供高效支撑：16GB 显存即可覆盖模型加载到 batch=4 并发的全流程，单请求吞吐量 15.6-17.6 tokens/秒、批量总吞吐量达 63.33 tokens/秒（近线性增长），同时兼具低延迟波动（≤0.22 秒标准差）、全场景适配（中/英文、文本/代码/对话）及可复现部署方案，既降低硬件选型成本，又为国产算力下大模型落地提供稳定可靠的性能保障。

生产环境部署性价比突出，实时场景推荐选用 batch=16，以 3.09 秒低延迟实现 258.40 tokens/秒的总吞吐量；离线批量场景则可采用 batch=128，以 3.15 秒的小幅延迟提升，换取 123.9 倍于单请求的吞吐量，大幅提升处理效率。当前的 NPU 算子融合、显存池等优化配置完全适配大 batch 场景，无需额外调整即可直接用于生产部署。