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. 环境配置检查

进入终端检查深度学习环境核心配置，包括操作系统、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__}')"

2. 依赖安装与环境准备

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

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

Llama-2-7B 模型加载与推理测试部署

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

Llama-2-7B 在昇腾 NPU 上的性能基准测试

前提准备：测评脚本编写

编写测评脚本代码 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"

def get_environment_info():
    return {
        "torch 版本": torch.__version__,
        "torch_npu 版本": getattr(torch_npu, "__version__", "未知"),
        "transformers 版本": __import__("transformers").__version__,
        "NPU 设备": DEVICE,
        "模型名称": MODEL_NAME,
        "模型精度": PRECISION
    }

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：")
        dtype = torch.float16
        model = AutoModelForCausalLM.from_pretrained(
            model_name, torch_dtype=dtype, low_cpu_mem_usage=
        ).to(DEVICE)
    model.()
    end_load = time.time()
    load_time = end_load - start_load
    mem_used = torch.npu.memory_allocated() / 
    ()
     model, tokenizer, load_time, mem_used, (dtype)

 ():
    batch_inputs = [prompt] * batch_size
    inputs = tokenizer(
        batch_inputs, return_tensors=, padding=,
        truncation=, max_length=
    ).to(DEVICE)

    ()
     _  (WARMUP_RUNS):
         torch.no_grad():
            _ = model.generate(
                **inputs, max_new_tokens=max_new_tokens,
                do_sample=, pad_token_id=tokenizer.eos_token_id,
                eos_token_id=tokenizer.eos_token_id
            )

    latencies = []
    ()
     i  (TEST_RUNS):
        torch.npu.synchronize()
        start = time.time()
         torch.no_grad():
            outputs = model.generate(
                **inputs, max_new_tokens=max_new_tokens,
                do_sample=, pad_token_id=tokenizer.eos_token_id,
                eos_token_id=tokenizer.eos_token_id
            )
        torch.npu.synchronize()
        end = time.time()
        latency = end - start
        latencies.append(latency)
        ()

    avg_latency = (latencies) / (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() / 

     {
        : (avg_latency, ),
        : (std_latency, ),
        : (throughput, ),
        : (total_throughput, ),
        : (mem_peak, ),
        : max_new_tokens,
        : batch_size
    }

运行 python test.py 执行测评。

基础能力测评

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

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

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

核心性能测评

单请求多场景性能测评

覆盖'短/长文本、中/英文、代码、多轮对话'，单请求吞吐量稳定在 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 对批量推理的优化充分，适合高并发场景。

测试核心结论

性能稳定性：各场景单请求吞吐量稳定在 15.6-17.6 tokens/秒，延迟标准差≤0.22 秒。
批量效率：batch_size 从 1 增至 4 时，总吞吐量接近线性增长（3.9 倍），适合高并发部署。
显存需求：FP16 精度下，7B 模型加载显存 13.61GB，最大推理显存 16.04GB，适配 16GB 及以上 NPU。
场景适配：多语言（中/英文）、多任务（文本/代码/对话）性能均衡，无明显短板。

Llama 模型在昇腾 NPU 上的性能测试报告

两组实测数据结合起来看，Llama-2-7b 和昇腾 NPU 的适配既稳又能打。单请求下不管是英文生成、中文对话还是代码创作，吞吐量都稳定卡在 16.08-16.80 tokens/秒，长文本、多轮问答的性能波动也极小。批量场景更是把算力优势拉满了，batch 从 2 升到 4 时，总吞吐量直接从 32.39 冲到 63.33 tokens/秒，接近单请求的 4 倍。更省心的是显存控制：模型加载仅占 13.61GB，即便是 batch=4 的峰值也才 16.04GB，普通 16GB 显存就能覆盖全流程。

高并发线性增长极限测试

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

import os
os.environ["NPU_FUSION_ENABLE"] = "1"
os.environ["ASCEND_GLOBAL_MEM_POOL_SIZE"] = "8589934592"
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"

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

Llama-2-7b 昇腾 NPU 性能优化方案

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

修改原有 llama.py 推理逻辑

补充 pad_token，确保 KV 缓存开启。

# ... 省略部分代码 ...
tokenizer.pad_token = tokenizer.eos_token
# ... 省略部分代码 ...
outputs = model.generate(
    **inputs, max_new_tokens=50, use_cache=True,
    cache_implementation="npu_optimized",
    do_sample=False, num_beams=1,
    pad_token_id=tokenizer.pad_token_id,
    eos_token_id=tokenizer.eos_token_id
)

修改原有 Test.py 的 benchmark 函数

优化版 benchmark 函数补充 pad_token，适配批量推理，开启 KV 缓存。

模型部署所需依赖安装与环境准备 - 实操问题及解决方案

国内镜像源安装依赖失败

切换多源镜像兜底，如阿里云或华为源。

pip install transformers accelerate \
-i https://mirrors.aliyun.com/pypi/simple/ \
--trusted-host mirrors.aliyun.com

torch_npu 版本不兼容

严格匹配版本安装。

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

依赖包版本冲突

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

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

总结

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

Llama-2-7b 昇腾 NPU 测评总结：核心性能数据与硬件选型参考