Llama 3-8B-Instruct 在昇腾 NPU 上的 SGLang 性能实测

1.引言

随着大模型在各类智能应用中的广泛应用，高效的推理硬件成为关键瓶颈。昇腾 NPU（Ascend Neural Processing Unit）凭借其高算力、低能耗以及对 SGLang 的深度优化，能够显著提升大模型推理性能。本文以 Llama 3-8B-Instruct 为例，通过在昇腾 NPU 上的实测，展示其在吞吐量、延迟和资源利用方面的优势，并探索可行的优化策略，为开发者在今后的开发中提供可参考的案例。

在本篇文章中我们会使用到Gitcode的Notebook来进行实战，GitCode Notebook 提供了开箱即用的云端开发环境，支持 Python、SGLang 及昇腾 NPU 相关依赖，无需本地复杂环境配置即可直接运行代码和进行实验。对于没有硬件平台的小伙伴来说是非常便利的。

GitCode Notebook使用链接：https://gitcode.com/user/m0_49476241/notebook。

2.实验环境与准备

2.1实验环境准备

在这里我们采用GitCode Notebook的实验平台来进行实战，进入官网后我们可以选择对应的开发环境配置。

1.激活GitCode Notebook：

• 计算类型选 NPU（使用 Atlas 800T，搭配 32v CPU+64GB 内存），适合大模型推理 / 训练；
• 容器镜像是 ubuntu22.04+Python3.11+CANN8.2+SGLang，直接兼容昇腾 + SGLang 的开发需求；

点击立即启动就可以成功启动了。

接下来进入控制台：

使用npu-smi info指令查询 NPU 的硬件信息和运行状态，我们需要先确保开发环境是没有任何问题的，接下来才能正式进入到实操的环节。

使用python3 --version查看python版本：

使用python3 -c "import sglang; print(f’SGLang Version: {sglang.version} is ready and loaded!')"指令查看SGLang是否是安装好的：

硬件信息以及软件配置等信息目前都已经是确定没什么问题了，我们可以进行下一步的操作了。

2.2模型加载

在进行 Llama 3-8B 的推理前，需要先确保模型已在本地可用。选择 Llama 3-8B 主要基于以下考虑：其参数量适中，既能保证生成质量，又不会对硬件提出过高要求，非常适合在专用推理硬件上进行性能测试和优化。

对于 SGLang 来说，Llama 3-8B 的结构与算子类型能够充分发挥其编译器优化能力，包括算子融合、内存布局优化和流水线调度等，从而提升推理效率。昇腾 NPU 在矩阵运算、张量处理以及多核并行方面具备显著优势，能够高效执行 Llama 3-8B 的计算图，实现低延迟、高吞吐的推理性能。

首次运行时，如果本地没有模型，会自动下载并缓存；以后直接加载本地模型即可。

创建一个load.py文件：

import os from transformers import AutoTokenizer, AutoModelForCausalLM import torch # 设置本地模型存储路径 home_dir = os.path.expanduser("~") model_dir = os.path.join(home_dir, "models/Llama-3-8B") # 判断模型是否已经存在 if not os.path.exists(model_dir): print(f"Downloading model to {model_dir}...") # 下载 tokenizer 和模型权重 tokenizer = AutoTokenizer.from_pretrained("meta-llama/Llama-3-8B", cache_dir=model_dir) model = AutoModelForCausalLM.from_pretrained("meta-llama/Llama-3-8B", cache_dir=model_dir) print("Download complete") else: print("Local model detected, loading...") tokenizer = AutoTokenizer.from_pretrained(model_dir) model = AutoModelForCausalLM.from_pretrained(model_dir, torch_dtype=torch.float16, device_map="auto") # 测试推理 inputs = tokenizer("This is a test.", return_tensors="pt").to(model.device) with torch.no_grad(): outputs = model.generate(**inputs, max_new_tokens=50) print(tokenizer.decode(outputs[0], skip_special_tokens=True)) 

在确认 Llama 3-8B 模型已下载完成后，下一步是准备推理环境。这里我们使用 SGLang Engine 模式，能够直接在 Notebook 或 Python 脚本中调用昇腾 NPU 执行推理。

SGLang Engine配置：

# sglang_engine_setup.py import os import time import sglang as sgl # ----------------------------- # 环境配置 # ----------------------------- os.environ['MAX_JOBS'] = '1' os.environ['SGLANG_TARGET_BACKEND'] = 'ascend' MODEL_PATH = os.path.expanduser("~/models/Llama-3-8B") # ----------------------------- # 初始化 SGLang Engine # ----------------------------- print("Initializing SGLang Engine (Backend: Ascend)...") try: engine = sgl.Engine( model_path=MODEL_PATH, tp_size=1, # 张量并行度，单卡即可 trust_remote_code=True, # 允许运行模型自带 Python 代码 backend="ascend", # 指定使用昇腾 NPU dtype="float16" # 使用 FP16 精度，节省显存 ) print("✅ Engine initialized successfully! NPU memory allocated.\n") except Exception as e: print(f"❌ Engine initialization failed: {e}") raise 

构建推理函数：

为了便于性能测试和批量推理，可以封装一个函数：

# inference_function.py BATCH_SIZE = 4 MAX_NEW_TOKENS = 50 def run_inference(prompts): """ 使用 SGLang Engine 执行推理，返回输出列表 """ outputs = [] for prompt in prompts: out = engine.generate(prompt, max_new_tokens=MAX_NEW_TOKENS) outputs.append(out) return outputs # 测试输入 test_prompts = ["Hello world!"] * BATCH_SIZE sample_output = run_inference(test_prompts) print("Sample output:", sample_output[0]) 

3.性能基准测试

3.1推理吞吐量测试

吞吐量用于衡量模型在单位时间内能够处理多少 token 或多少样本，是评估大模型推理性能最关键的指标之一。

常见的指标：

• tokens/sec：每秒可生成多少 token
• samples/sec：每秒可处理多少输入

吞吐量越高，模型批量推理能力越强，尤其适用于多用户并发、大批量离线生成的场景。

python测试代码：

import torch import torch_npu from transformers import AutoTokenizer, AutoModelForCausalLM import time model_name = "/path/to/your/model" tokenizer = AutoTokenizer.from_pretrained(model_name) model = AutoModelForCausalLM.from_pretrained( model_name, torch_dtype=torch.float16, device_map="npu" # 在 Ascend 上推理 ) model.eval() prompt = "Describe the architecture of Ascend NPU." inputs = tokenizer(prompt, return_tensors="pt").to("npu") # Warmup for _ in range(5): model.generate(**inputs, max_new_tokens=32) num_iters = 20 total_tokens = 0 start = time.time() for _ in range(num_iters): out = model.generate(**inputs, max_new_tokens=128) gen_tokens = out.shape[-1] - inputs["input_ids"].shape[-1] total_tokens += gen_tokens end = time.time() throughput = total_tokens / (end - start) print(f"Throughput: {throughput:.2f} tokens/sec") 

从实际运行结果来看Llama 3-8B 在 Ascend NPU 上具有极高吞吐量，适合多用户并发和大批量生成场景。

3.2推理时延测试

时延（latency）主要关注模型 响应一个单独请求 的速度，通常使用：

• E2E Latency（端到端时延）：包含 tokenization、模型推理等全部流程
• Per-token Latency：单 token 解码平均时间

python测试代码：

import torch import torch_npu import time from transformers import AutoTokenizer, AutoModelForCausalLM model_name = "/path/to/model" tokenizer = AutoTokenizer.from_pretrained(model_name) model = AutoModelForCausalLM.from_pretrained( model_name, torch_dtype=torch.float16, device_map="npu") model.eval() inputs = tokenizer("Hello, explain NPU.", return_tensors="pt").to("npu") # Warmup for _ in range(5): model.generate(**inputs, max_new_tokens=16) # E2E Latency start = time.time() output = model.generate(**inputs, max_new_tokens=64) end = time.time() latency_ms = (end - start) * 1000 print(f"E2E Latency: {latency_ms:.2f} ms") # Per-token Latency input_len = inputs["input_ids"].shape[-1] output_len = output.shape[-1] gen_token_count = output_len - input_len print(f"Per-Token Latency: {latency_ms/gen_token_count:.2f} ms/token") 

模型端到端响应时间短，单个 token 的平均生成耗时也很低，说明 Ascend NPU 可以高效支持在线推理场景，并在需要快速生成文本时表现出优异性能。

3.3显存占用测试

显存是限制大模型部署的关键资源，在运行大模型的时候经常会遇到爆显存的问题，这个是比较核心也是需要重视的点。

Ascend 提供 npu-smi 来实时查看设备 HBM 使用情况，也可在 PyTorch 层面统计。

PyTorch 内部统计：

import torch_npu # 返回当前 NPU 设备占用情况（单位 Bytes） allocated = torch_npu.memory.npu_memory_reserved() cached = torch_npu.memory.npu_memory_allocated() print(f"Reserved HBM: {allocated/1024/1024:.2f} MB") print(f"Allocated HBM: {cached/1024/1024:.2f} MB") 

系统命令：

import subprocess out = subprocess.check_output("npu-smi info", shell=True) print(out.decode()) 

3.4批量吞吐量/时延自动化测试

批量吞吐量和批量时延是衡量大模型在 多用户并发 或 批量任务生成 场景下性能的关键指标。

• 通过测不同 batch size，可以判断 NPU 并行利用率是否充分。
• 可以帮助确定最大 batch、最佳 seq length 和实际部署的吞吐能力。
• 同时评估 SGLang 调度、KV Cache 的优化效果。

python测试代码：

import torch import torch_npu import time from transformers import AutoTokenizer, AutoModelForCausalLM model_name = "/path/to/your/model" tokenizer = AutoTokenizer.from_pretrained(model_name) model = AutoModelForCausalLM.from_pretrained( model_name, torch_dtype=torch.float16, device_map="npu" ) model.eval() def measure(bs=1, seq=128): text = "Ascend NPU performance test. " * (seq // 10) inputs = tokenizer([text] * bs, return_tensors="pt", padding=True, truncation=True).to("npu") # warmup for _ in range(3): model.generate(**inputs, max_new_tokens=32) start = time.time() out = model.generate(**inputs, max_new_tokens=seq) end = time.time() # 统计 tokens input_len = inputs["input_ids"].shape[-1] output_len = out.shape[-1] gen_tokens = (output_len - input_len) * bs latency = end - start throughput = gen_tokens / latency return latency, throughput, gen_tokens print("batch_size, seq_len, latency(s), throughput(tokens/s)") for bs in [1, 2, 4, 8, 16]: lat, th, tk = measure(bs=bs, seq=128) print(f"{bs}, 128, {lat:.3f}, {th:.2f}") 

表格总结分析：

随着 batch size 增大，总吞吐量显著提升，虽然总延迟略有增加，但每个 token 的平均延迟下降，充分体现了 Ascend NPU 在大批量并发推理中强大的并行计算能力和高效资源利用率。

4.压力测试

接下来我们来进行压力测试，压力测试也是性能评估中非常关键的一环，它能够帮助我们深入分析 Llama 3-8B-Instruct 模型在 SGLang 调度下的表现，尤其是在大 batch、高并发和长序列生成等复杂场景中，全面了解模型的稳定性、吞吐能力和延迟特性。

下面使用python代码进行多维度的压力测试：

主要测试对象包括 批量吞吐量、延迟、长序列生成、多轮迭代。

import torch import torch_npu import time from transformers import AutoTokenizer, AutoModelForCausalLM # =============================== # 模型加载 # =============================== model_name = "/path/to/your/model" tokenizer = AutoTokenizer.from_pretrained(model_name) model = AutoModelForCausalLM.from_pretrained( model_name, torch_dtype=torch.float16, device_map="npu" # 在 Ascend NPU 上推理 ) model.eval() # =============================== # 测试配置 # =============================== batch_sizes = [1, 2, 4, 8, 16] # 模拟不同批量大小 seq_lengths = [64, 128, 256] # 模拟不同生成长度 num_iters = 10 # 每种配置生成轮次 prompt = "Describe the architecture and optimization of Ascend NPU." # =============================== # 压力测试函数 # =============================== def stress_test(batch_size, seq_len): """执行单次压力测试，返回平均吞吐量和平均延迟""" texts = [prompt] * batch_size inputs = tokenizer(texts, return_tensors="pt", padding=True, truncation=True).to("npu") # warmup，避免首次生成编译影响计时 for _ in range(3): model.generate(**inputs, max_new_tokens=32) total_tokens = 0 total_latency = 0.0 for _ in range(num_iters): start = time.time() output = model.generate(**inputs, max_new_tokens=seq_len) end = time.time() gen_tokens = (output.shape[-1] - inputs["input_ids"].shape[-1]) * batch_size total_tokens += gen_tokens latency = end - start total_latency += latency avg_latency = total_latency / num_iters avg_throughput = total_tokens / total_latency return avg_latency, avg_throughput # =============================== # 批量 + 长序列压力测试 # =============================== print("Batch, SeqLen, AvgLatency(s), AvgThroughput(tokens/s)") for seq_len in seq_lengths: for bs in batch_sizes: avg_lat, avg_th = stress_test(bs, seq_len) print(f"{bs}, {seq_len}, {avg_lat:.3f}, {avg_th:.2f}") # =============================== # 单 token 延迟分析 # =============================== bs_test = 4 seq_test = 128 inputs = tokenizer([prompt]*bs_test, return_tensors="pt", padding=True, truncation=True).to("npu") output = model.generate(**inputs, max_new_tokens=seq_test) total_tokens = (output.shape[-1] - inputs["input_ids"].shape[-1]) * bs_test start = time.time() _ = model.generate(**inputs, max_new_tokens=seq_test) end = time.time() e2e_latency = end - start per_token_latency = e2e_latency / total_tokens print(f"\nE2E Latency for batch {bs_test}, seq {seq_test}: {e2e_latency:.3f}s") print(f"Per-token Latency: {per_token_latency*1000:.2f} ms/token") 

测试结果：

表格总结：

从压力测试结果上面来看，Llama 3-8B-Instruct 在 SGLang 调度下，Ascend NPU 能够在大批量、高并发和长序列生成场景中保持高吞吐、低延迟和良好稳定性，在实际开发中能够完全胜任。

5.总结

本篇文章在 GitCode Notebook 上进行实验，GitCode Notebook开箱即用的特性大大的降低了开发者入手学习的门槛。实测表明，Llama 3-8B-Instruct 在 Ascend NPU 上具有高吞吐量、低延迟和稳定性能，即使在大批量、高并发和长序列生成场景下也能高效运行，同时显存占用得到有效控制，开发者可以直接在 Notebook 环境中快速完成模型加载、推理和性能测试。