PythonAI算法
Llama-2-7B 昇腾 NPU 性能测评与部署实践
Llama-2-7B 模型在昇腾 NPU 环境下完成全流程部署与性能测试。单请求吞吐量稳定在 15.6-17.6 tokens/秒，batch=4 时总吞吐量达 63.33 tokens/秒，显存占用约 16GB。高并发测试显示 batch 增至 70 时仍保持线性增长，延迟波动小。提供环境配置、依赖安装、算子融合优化及常见问题解决方案，适用于国产化算力大模型落地场景。
Llama-2-7B 模型在昇腾 NPU 环境下完成全流程部署与性能测试。单请求吞吐量稳定在 15.6-17.6 tokens/秒，batch=4 时总吞吐量达 63.33 tokens/秒，显存占用约 16GB。高并发测试显示 batch 增至 70 时仍保持线性增长，延迟波动小。提供环境配置、依赖安装、算子融合优化及常见问题解决方案，适用于国产化算力大模型落地场景。
本文旨在适配大模型国产化部署需求，以 Llama-2-7b 为对象，在云端 Notebook 昇腾 NPU 环境中完成从依赖安装到模型部署的全流程落地。通过六大维度测评验证：单请求吞吐量稳定 15.6-17.6 tokens / 秒，batch=4 时总吞吐量达 63.33 tokens / 秒，16GB 显存即可支撑高并发，最终提供可复现的部署方案、性能基准数据及硬件选型建议。
昇腾 NPU：以华为自研达芬奇架构为核心，高效张量计算适配大模型全场景；搭载 CANN 架构简化开发，支持量化与混合并行技术平衡算力与能耗，深度兼容开源生态适配国产化需求。
Llama-2-7B 模型：Meta 开源 70 亿参数大模型，文本生成与推理能力优异；轻量化设计部署灵活，支持微调定制适配多业务场景，提供商业授权兼顾开源灵活与企业合规需求。
# 检查系统版本
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__}')"
pip install transformers accelerate -i https://pypi.tuna.tsinghua.edu.cn/simple
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")
export HF_ENDPOINT=https://hf-mirror.com
import torch
import torch_npu
import time
import json
import pandas as pd
from datetime import datetime
import transformers
from transformers import AutoModelForCausalLM, AutoTokenizer
MODEL_NAME = "NousResearch/Llama-2-7b-hf"
DEVICE = "npu:0"
WARMUP_RUNS = 5
TEST_RUNS = 10
SAVE_RESULT = True
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},
{"场景": "长文本叙事", "输入": "请写一篇关于人工智能未来的科幻短篇：", : , : },
{: , : , : , : },
{: , : , : , : },
]
PRECISION =
():
{
: torch.__version__,
: torch_npu.__version__ (torch_npu, ) ,
: transformers.__version__,
: ,
: DEVICE,
: MODEL_NAME,
: PRECISION
}
():
()
start_load = time.time()
tokenizer = AutoTokenizer.from_pretrained(model_name)
dtype = torch.float16 precision == torch.int8
:
model = AutoModelForCausalLM.from_pretrained(
model_name, torch_dtype=dtype, low_cpu_mem_usage=
).to(DEVICE)
Exception e:
()
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
}
():
load_time, load_mem, actual_dtype = load_metrics
df = pd.DataFrame(results)
short_text_throughput = df[df[] == ][].iloc[]
long_text_throughput = df[df[] == ][].iloc[]
batch2_throughput = df[df[] == ][].iloc[]
batch4_throughput = df[df[] == ][].iloc[]
summary =
summary
__name__ == :
env_info = get_environment_info()
()
k, v env_info.items():
()
model, tokenizer, load_time, load_mem, actual_dtype = load_model_and_tokenizer(MODEL_NAME, PRECISION)
load_metrics = (load_time, load_mem, actual_dtype)
results = []
TEST_CASES:
()
case_result = benchmark(
prompt=[],
tokenizer=tokenizer,
model=model,
max_new_tokens=[],
batch_size=[]
)
case_result.update({
: [],
: [][:] + ([]) > [],
: datetime.now().strftime()
})
results.append(case_result)
()
( + *)
()
(*)
detailed_summary = generate_detailed_summary(results, env_info, load_metrics)
(detailed_summary)
SAVE_RESULT:
timestamp = datetime.now().strftime()
json_filename =
(json_filename, , encoding=) f:
json.dump({
: env_info,
: {: load_time, : load_mem, : actual_dtype},
: results
}, f, ensure_ascii=, indent=)
summary_filename =
(summary_filename, , encoding=) f:
f.write(detailed_summary)
()
()
()
()
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 |
结论：无环境波动干扰，性能数据可直接对比
模型从启动到就绪的性能表现，受缓存 / 网络轻微影响，但核心显存需求固定
| 加载指标 | 实测结果 | 补充说明 |
|---|---|---|
| 加载耗时 | 30.75 ~ 35.62 秒 | 首次加载因缓存慢，后续变快，波动正常 |
| 加载后显存占用 | 13.61 GB（完全固定） | 模型权重初始化显存需求无差异 |
| 加载过程稳定性 | 100% 成功，无失败 / 卡顿 | 依赖昇腾工具链适配正常 |
结论：加载阶段显存可控，耗时波动在合理范围（±15% 内）
覆盖'短/长文本、中/英文、代码、多轮对话'，单请求吞吐量稳定在 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 | 长文本吞吐量无骤降（较 50token 仅 ±4.5%） |
| 多轮问答 | 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 | 接近线性增长（理论 4） |
结论：昇腾 NPU 对批量推理的优化充分，适合高并发场景（如 API 服务、批量文本生成）
通过 10 次重复测试（TEST_RUNS=10）验证性能波动范围，排除偶然因素
| 稳定性指标 | 实测结果 | 行业参考标准 | 稳定性结论 |
|---|---|---|---|
| 延迟标准差 | 各场景≤0.22 秒 | 优秀标准：≤0.5 秒 | 延迟抖动小，用户体验稳定 |
| 吞吐量波动范围 | 各场景≤10% | 优秀标准：≤15% | 吞吐量无大幅波动，服务能力可控 |
| 测试成功率 | 100%（无中断 / 报错） | 合格标准：≥99% | 推理过程稳定，无异常退出 |
结论：NPU 驱动与 torch_npu 适配稳定，模型推理无'偶发慢请求'，适合线上生产环境
跟踪'加载 - 单请求 - 批量'全流程显存变化，明确不同阶段的资源需求
| 显存测评阶段 | 实测显存占用（FP16 精度） | 显存变化原因 | 资源结论 |
|---|---|---|---|
| 模型加载阶段 | 13.61 GB（固定） | 仅加载模型权重，无冗余 | 初始化显存需求明确，无浪费 |
| 单请求推理阶段 | 13.71 ~ 14.83 GB | 随生成长度略有上升（+0.1~1.2GB） | 单请求显存增量可控 |
| 批量推理阶段（batch=4） | 16.04 GB（最高） | 随 batch_size 增大，特征图缓存增加 | 16GB 显存可支撑 batch=4 的高并发 |
结论：Llama-2-7b 在昇腾 NPU 上的显存需求清晰，16GB 显存可覆盖'单请求 + batch=4 并发'，硬件选型成本可控
✅性能稳定性：各场景单请求吞吐量稳定在 15.6-17.6 tokens / 秒，延迟标准差≤0.22 秒，NPU 推理波动小
✅批量效率：batch_size 从 1 增至 4 时，总吞吐量接近线性增长（3.9 倍），适合高并发部署
✅显存需求：FP16 精度下，7B 模型加载显存 13.61GB，最大推理显存 16.04GB，适配 16GB 及以上 NPU
✅场景适配：多语言（中/英文）、多任务（文本/代码/对话）性能均衡，无明显短板
两组实测数据结合起来看，Llama-2-7b 和昇腾 NPU 的适配算是既稳又能打：单请求下不管是英文生成、中文对话还是代码创作，吞吐量都稳定卡在 16.08-16.80 tokens / 秒，长文本、多轮问答的性能波动也极小，连延迟标准差都压在 0.22 秒以内，能明显感觉到昇腾 NPU 对不同任务的兼容度和稳定性都很扎实。批量场景更是把算力优势拉满了 ——batch 从 2 升到 4 时，总吞吐量直接从 32.39 冲到 63.33 tokens / 秒，接近单请求的 4 倍，这种线性增长几乎没浪费算力，高并发场景下的潜力肉眼可见。更省心的是显存控制：模型加载仅占 13.61GB，即便是 batch=4 的峰值也才 16.04GB，普通 16GB 显存就能覆盖全流程，不用额外堆硬件成本。实际用下来，不管是多语言任务还是长序列推理，性能、延迟、显存的表现都很均衡，既能扛住高并发，又能稳得住不同场景的需求，算是国产化大模型落地里性价比加实用性双在线的组合。
✅环境信息维度：本次测试硬件采用昇腾 NPU 设备，软件层面选择 Llama-2-7b-hf 模型，以 fp16 精度运行，同时匹配了 torch 2.1.0、transformers 4.35.2、Python 3.9.x 的依赖版本，从启动效率来看，模型加载耗时 35.52 秒，加载阶段显存占用 13.62GiB，峰值达到 16.08GiB，这个加载速度和显存占用水平在 7B 级模型中算是比较常规的表现
✅性能指标维度：单请求场景下，batch_size 设置为 1、生成长度 50 时，吞吐量能达到 16.08 tokens/s，当 batch_size 提升至 4 后，批量总吞吐量直接冲到 63.33 tokens/s，接近线性增长的表现实在让人惊喜。延迟方面也很让人放心，单 batch 场景下平均延迟集中在 3 到 7 秒区间，而且延迟标准差基本都低于 1 秒，稳定性相当不错。更难得的是显存资源消耗全程保持稳定，各测试场景的显存峰值都维持在 13 到 16GiB 范围内，不会出现突然飙升的情况
✅场景细分维度：测试覆盖了多类实际落地场景还细化了参数组合，具体包含英文文本生成、中文对话、代码生成、长文本叙事、多轮问答等典型任务，每个场景都搭配了 1、2、4 的 batch_size，以及 50、100、150、200 的生成长度。比如中文对话中生成长度 150 时，吞吐量为 15.35 tokens/s、延迟 9.77 秒，代码生成中生成长度 200 时，吞吐量 16.44 tokens/s、延迟 12.17 秒，多轮问答场景的延迟标准差仅 0.123，这么多场景都能有稳定表现，充分体现了场景适配的全面性，实际落地时选择空间很大。
✅分析结论维度：测试数据中能得出特别清晰的性能规律，最让我意外的是文本长度对吞吐量的影响居然这么小，生成长度从 50 增至 200 时，吞吐量仅从 16.08 tokens/s 微降至 16.00 tokens/s，这种稳定性实在太突出了。而且批量并发的性能增益特别明显，batch_size 设置为 4 时的吞吐量是单 batch 的 3.9 倍，几乎接近理想的线性提升，效率提升很可观。同时多场景下的表现高度一致，各任务的吞吐量稳定在 15 到 16 tokens/s 区间，延迟标准差也普遍较低，能看出模型在不同业务场景下的适配性真的很强，不用为场景切换后的性能波动操心。
✅优化建议维度：结合测试数据，能明确给出很实用的优化与部署方向，性能层面优先采用批量推理，把 batch_size 设置为 4，就能显著提升吞吐量，这个优化方式简单直接，效果还特别好。显存方面，要是需要压缩资源，建议尝试 int8 精度，不过得提前验证精度损失情况，也可以通过算子优化进一步降低显存占用，灵活度很高。场景适配则要区分需求，实时对话类场景建议用 batch_size 为 1，这样能最大程度保证低延迟，批量生成类场景就用 batch_size 为 4，效率能拉满，而且长文本场景完全可以结合当前稳定的性能表现直接落地，不用额外做太多调整，部署起来很省心。
配置 NPU 算子融合、显存池等优化项，再以 FP16 低内存加载模型并适配批量推理；核心通过显存预检查规避 OOM，对 1~70 的 batch_size 完成预热和多轮测试，采集延迟、吞吐量、显存峰值等指标，最终计算增长衰减率，生成可视化报告并保存 JSON/CSV 数据，精准验证 7B 模型在 64GB 卡上 60-70 batch_size 的性能表现
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 = 3
TEST_RUNS = 5
BS_RANGE = [1, 4, 8, 16, 32, 40, 50, 60, 64, 70]
MAX_NEW_TOKENS = 50
PROMPT = "The capital of France is"
PRECISION = torch.float16
SAVE_RESULT = True
def set_npu_optim_config():
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"
print("✅ 高并发 NPU 优化配置已生效")
def check_mem_available(batch_size):
torch.npu.synchronize()
mem_total = torch.npu.get_device_properties(0).total_memory /
mem_used = torch.npu.memory_allocated() /
mem_free = mem_total - mem_used
mem_estimated = + (batch_size * )
mem_estimated > (mem_free * ):
RuntimeError(
)
()
():
()
start_load = time.time()
tokenizer = AutoTokenizer.from_pretrained(MODEL_NAME)
tokenizer.pad_token = tokenizer.eos_token
tokenizer.padding_side =
model = AutoModelForCausalLM.from_pretrained(
MODEL_NAME,
torch_dtype=PRECISION,
low_cpu_mem_usage=,
device_map={: DEVICE}
).()
param model.parameters():
param.requires_grad =
load_time = time.time() - start_load
mem_used = torch.npu.memory_allocated() /
()
model, tokenizer
():
check_mem_available(batch_size)
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,
use_cache=,
cache_implementation=
)
latencies = []
mem_peaks = []
()
i (TEST_RUNS):
torch.npu.synchronize()
start = time.time()
torch.no_grad():
_ = model.generate(
**inputs,
max_new_tokens=MAX_NEW_TOKENS,
do_sample=,
pad_token_id=tokenizer.eos_token_id,
use_cache=,
cache_implementation=
)
torch.npu.synchronize()
end = time.time()
latency = end - start
latencies.append(latency)
mem_peak = torch.npu.max_memory_allocated() /
mem_peaks.append(mem_peak)
throughput_single = MAX_NEW_TOKENS / latency
throughput_total = throughput_single * batch_size
()
avg_latency = (latencies) / (latencies)
avg_throughput_single = MAX_NEW_TOKENS / avg_latency
avg_throughput_total = avg_throughput_single * batch_size
avg_mem_peak = (mem_peaks) / (mem_peaks)
std_latency = pd.Series(latencies).std()
{
: batch_size,
: (avg_latency, ),
: (std_latency, ),
: (avg_throughput_single, ),
: (avg_throughput_total, ),
: (avg_mem_peak, ),
: (avg_throughput_total / benchmark_bs.bs1_throughput, ) benchmark_bs.bs1_throughput
}
():
df = pd.DataFrame(results)
df[] = df[] * df[df[]==][].iloc[]
df[] = ((df[] - df[]) / df[] * , )
report =
report, df
__name__ == :
set_npu_optim_config()
model, tokenizer = load_model()
results = []
benchmark_bs.bs1_throughput =
bs BS_RANGE:
()
()
()
:
res = benchmark_bs(model, tokenizer, bs)
results.append(res)
bs == :
benchmark_bs.bs1_throughput = res[]
Exception e:
()
results:
report, df = generate_report(results)
()
()
()
(report)
SAVE_RESULT:
timestamp = datetime.now().strftime()
(, , encoding=) f:
json.dump(results, f, ensure_ascii=, indent=)
df.to_csv(, index=, encoding=)
(, , encoding=) f:
f.write(report)
()
()
()
()
:
()
torch.npu.empty_cache()
()
从这张测试结果截图来看，Llama-2-7B 在昇腾 NPU（64GB 显存）上的高并发性能表现依然优秀，且验证了之前的核心结论，清晰呈现了 Llama-2-7B 模型在昇腾显存下不同 batch_size 的核心性能指标：从 batch=1 到 70，单请求吞吐量稳定在 16tokens / 秒左右，总吞吐量随 batch_size 线性增长，70 batch 时达 1125.87 tokens / 秒，是单请求的 68.73 倍；平均延迟始终维持在 3.0~3.1 秒区间，显存峰值仅从 13.71GB 增至 17.68GB，资源占用极低；增长衰减率整体可控，50-64 batch 甚至出现负衰减，实际性能超理论预期，70 batch 时仅 1.81%，充分验证 64GB 卡支撑 60-70 batch_size 具备高稳定性和线性增长特性。
核心结论
CSV 表格数据
测试报告
关键表现总结
本次测试中 Llama-2-7B 在昇腾上展现出极强的性能稳定性与线性增长能力，从 batch=1 到 batch=128，平均延迟仅从 3.05 秒微增至 3.15 秒，增幅仅 3.28%，且延迟标准差始终≤0.03 秒，用户无感知波动；单请求吞吐量衰减仅 3.23%，远优于行业平均水平。batch=128 时总吞吐量达 2028.80 tokens / 秒，是单请求的 123.9 倍，增长衰减率仅 5%，突破大 batch 下的性能衰减瓶颈。同时显存利用率表现极致，batch=128 时显存峰值仅 20.12GB，仅占用 64GB 显存的 31.4%，剩余大量显存可支撑更大 batch 并发测试，且显存占用远低于同类 GPU 硬件，充分体现昇腾 NPU 的显存优化优势
核心结论总结
本次测试验证了昇腾 NPU 对 Llama-2-7B 批量推理的支持无明显上限，在 batch=128 时仍能将增长衰减率控制在 5% 以内，算力利用率处于极高水平；生产环境部署性价比突出，实时场景推荐选用 batch=16，以 3.09 秒低延迟实现 258.40 tokens / 秒的总吞吐量，离线批量场景则可采用 batch=128，以 3.15 秒的小幅延迟提升，换取 123.9 倍于单请求的吞吐量，大幅提升处理效率；当前的 NPU 算子融合、显存池等优化配置完全适配大 batch 场景，无需额外调整即可直接用于生产部署。
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 # 2GB
# 4. 优化 NPU 内存分配策略
export ASCEND_CACHE_CLEAR_INTERVAL=100
# 5. 关闭冗余日志输出，减少开销
export NPU_PRINT_TENSOR_SIZE=0
修改原有 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)
tokenizer.pad_token = tokenizer.eos_token
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", padding=True)
inputs = {k: v.npu() for k, v in inputs.items()}
torch.npu.synchronize()
start = time.time()
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,
max_length=inputs.input_ids.shape[1] + 50,
return_dict_in_generate=False
)
torch.npu.synchronize()
end = time.time()
text = tokenizer.decode(outputs[0], skip_special_tokens=True)
print(f"\n生成文本：{text}")
print(f"耗时：{(end-start)*1000:f}ms")
()
修改原有 Test.py 的 benchmark 函数
def benchmark(prompt, tokenizer, model, max_new_tokens, batch_size):
tokenizer.pad_token = tokenizer.eos_token
batch_inputs = [prompt] * batch_size
inputs = tokenizer(
batch_inputs,
return_tensors="pt",
padding=True,
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,
use_cache=True,
cache_implementation="npu_optimized"
)
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,
use_cache=True,
cache_implementation="npu_optimized",
max_length=inputs.input_ids.shape[1] + max_new_tokens,
return_dict_in_generate=False
)
torch.npu.synchronize()
end = time.time()
latency = end - start
latencies.append(latency)
print(f" 第{i+}次：耗时 秒 | 速度 tokens/秒")
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
}
集成优化配置后，Llama-2-7b 在昇腾 NPU 上的推理性能显著提升，各类生成场景下的吞吐量均有明显增长，同时显存占用降低、延迟稳定性大幅改善。适配时需补充 Llama-2 的 pad_token、确保 torch_npu 版本满足要求以兼容定制缓存、保留 NPU 同步机制，若采用 INT8 量化需验证 KV 缓存有效性。
具体现象：执行 pip install transformers accelerate 时报 ConnectionTimeout 或 404 错误
切换多源镜像兜底
# 使用阿里云镜像源安装 transformers、accelerate
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
具体现象：导入 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
验证 torch_npu 是否正确安装到当前 Python 环境
python -c "import torch_npu; print(torch_npu.npu.is_available())"
显示 True，说明安装正常、路径无冲突
具体现象：安装后执行代码时报 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 秒标准差）、全场景适配（中/英文、文本/代码/对话）及可复现部署方案，既降低硬件选型成本，又为国产算力下大模型落地提供稳定可靠的性能保障。
微信公众号「极客日志」，在微信中扫描左侧二维码关注。展示文案：极客日志 zeeklog
使用加密算法（如AES、TripleDES、Rabbit或RC4）加密和解密文本明文。 在线工具，加密/解密文本在线工具，online
生成新的随机RSA私钥和公钥pem证书。 在线工具，RSA密钥对生成器在线工具，online
基于 Mermaid.js 实时预览流程图、时序图等图表，支持源码编辑与即时渲染。 在线工具，Mermaid 预览与可视化编辑在线工具，online
解析常见 curl 参数并生成 fetch、axios、PHP curl 或 Python requests 示例代码。 在线工具，curl 转代码在线工具，online
将字符串编码和解码为其 Base64 格式表示形式即可。 在线工具，Base64 字符串编码/解码在线工具，online
将字符串、文件或图像转换为其 Base64 表示形式。 在线工具，Base64 文件转换器在线工具，online