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

运行前建议将 Hugging Face 下载源临时切换到国内镜像站：

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

性能基准测试

为了获得更准确的数据，我们编写了专门的测评脚本 Test.py。该脚本覆盖多种场景，包括英文短文本、中文对话、代码生成、长文本叙事等，并统计延迟标准差与吞吐量。

测评脚本核心逻辑

脚本包含全局配置区，用户仅需修改模型名称、设备 ID 及测试用例。核心函数 benchmark 实现了带预热、同步、多批次统计的性能测试逻辑。

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},
    {"场景": "高并发批量（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 参数需为布尔值或字符串
    inputs = tokenizer(
        batch_inputs,
        return_tensors="pt",
        padding=True if batch_size > 1 else False,
        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,
                pad_token_id=tokenizer.eos_token_id,
                eos_token_id=tokenizer.eos_token_id
            )

    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,
                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)
        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
    }

if __name__ == "__main__":
    model, tokenizer, load_time, load_mem, actual_dtype = load_model_and_tokenizer(MODEL_NAME, PRECISION)
    results = []
    for case in TEST_CASES:
        print(f"\n===== 开始测试场景：{case['场景']} =====")
        case_result = benchmark(
            prompt=case["输入"],
            tokenizer=tokenizer,
            model=model,
            max_new_tokens=case["生成长度"],
            batch_size=case["batch_size"]
        )
        case_result.update({"场景": case["场景"]})
        results.append(case_result)
    
    df = pd.DataFrame(results)
    print("\n===== 测试结果汇总 =====")
    print(df.to_string())

核心性能数据

结论：单请求场景下，模型对不同任务类型的适配性优异，无性能瓶颈。批量推理时，batch_size 从 1 增至 4，总吞吐量增长近 4 倍，说明 NPU 算力未饱和，适合高并发场景部署。

高并发极限测试

针对生产环境可能面临的大规模并发需求，我们进一步进行了高并发线性增长极限测试。配置 NPU 算子融合、显存池等优化项，对 batch_size 从 1 到 70 完成测试。

高并发测试脚本

import torch
import torch_npu
import os

# 高并发 NPU 环境优化
os.environ["NPU_FUSION_ENABLE"] = "1"
os.environ["ASCEND_GLOBAL_MEM_POOL_SIZE"] = "8589934592"
os.environ["NPU_ENABLE_CACHE_OP"] = "1"

def set_npu_optim_config():
    print("✅ 高并发 NPU 优化配置已生效")

def check_mem_available(batch_size):
    torch.npu.synchronize()
    mem_total = torch.npu.get_device_properties(0).total_memory / 1e9
    mem_used = torch.npu.memory_allocated() / 1e9
    mem_free = mem_total - mem_used
    mem_estimated = 13.6 + (batch_size * 0.5)
    if mem_estimated > (mem_free * 0.95):
        raise RuntimeError(f"❌ batch_size={batch_size} 预估显存不足")
    print(f"✅ batch_size={batch_size} 显存检查通过")

# ... 其余逻辑参考 Test.py 中的 benchmark 函数，重点在于开启 KV 缓存 ...

关键表现总结：从 batch=1 到 batch=70，单请求吞吐量稳定在 16 tokens/秒左右，总吞吐量随 batch_size 线性增长。70 batch 时达 1125.87 tokens/秒，是单请求的 68.73 倍。平均延迟始终维持在 3.0~3.1 秒区间，显存峰值仅从 13.71GB 增至 17.68GB，资源占用极低。

性能优化方案

集成优化配置后，Llama-2-7B 在昇腾 NPU 上的推理性能显著提升。以下是具体的优化步骤：

1. NPU 环境配置

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

2. 代码级优化

在推理逻辑中显式开启 KV 缓存，并指定昇腾定制缓存实现：

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
)

同时确保 torch_npu 版本满足要求以兼容定制缓存，保留 NPU 同步机制以保证计时准确。

常见问题与解决方案

国内镜像源安装依赖失败

执行 pip install 时报 ConnectionTimeout 或 404 错误，可切换多源镜像兜底：

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

torch_npu 版本不兼容

导入 torch_npu 时报 AttributeError，需严格匹配版本安装：

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 即表示路径无冲突。

依赖包版本冲突

若出现 ImportError，可清理冲突依赖后重新安装：

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/秒，且兼具低延迟波动、全场景适配及可复现部署方案。通过合理的硬件选型与参数调优，可为国产算力下大模型落地提供稳定可靠的性能保障。

相关资源：

• 昇腾官网：https://www.hiascend.com/
• 昇腾社区：https://www.hiascend.com/community
• 昇腾官方文档：https://www.hiascend.com/document
• 昇腾开源仓库：https://gitcode.com/ascend