chenchenghao/sglang
1
0
Fork 0
Code Issues Pull Requests Actions 11 Packages Projects Releases Wiki Activity

[NPU] update nightly tests (#17952)

Browse Source 
Co-authored-by: gemini-code-assist[bot] <176961590+gemini-code-assist[bot]@users.noreply.github.com>
Co-authored-by: cy <chenyang08056032@163.com>
This commit is contained in:
Sugar920
2026-02-03 00:13:30 +08:00
committed by GitHub
parent c971852ffc
commit c781db0f6c
52 changed files with 1703 additions and 69 deletions
Download Patch File Download Diff File Expand all files Collapse all files

197
test/registered/ascend/basic_function/interface/test_ascend_enable_thinking.py Normal file
View File

@@ -0,0 +1,197 @@
import json
import unittest
import requests
from sglang.srt.utils import kill_process_tree
from sglang.test.ascend.test_ascend_utils import QWEN3_30B_A3B_WEIGHTS_PATH
from sglang.test.ci.ci_register import register_npu_ci
from sglang.test.test_utils import (
DEFAULT_TIMEOUT_FOR_SERVER_LAUNCH,
DEFAULT_URL_FOR_TEST,
CustomTestCase,
popen_launch_server,
)
register_npu_ci(est_time=400, suite="nightly-2-npu-a3", nightly=True)
class TestEnableThinking(CustomTestCase):
"""Testcase: Testing with the 'enable_thinking' feature enabled/disabled,
both streaming and non-streaming input requests successful
[Test Category] Interface
[Test Target] /v1/chat/completions
"""
@classmethod
def setUpClass(cls):
cls.model = QWEN3_30B_A3B_WEIGHTS_PATH
cls.base_url = DEFAULT_URL_FOR_TEST
cls.api_key = "sk-1234"
cls.other_args = [
"--reasoning-parser",
"qwen3",
"--attention-backend",
"ascend",
"--disable-cuda-graph",
"--mem-fraction-static",
0.95,
"--tp",
2,
]
cls.process = popen_launch_server(
cls.model,
cls.base_url,
timeout=DEFAULT_TIMEOUT_FOR_SERVER_LAUNCH,
api_key=cls.api_key,
other_args=cls.other_args,
)
cls.additional_chat_kwargs = {}
@classmethod
def tearDownClass(cls):
kill_process_tree(cls.process.pid)
def test_chat_completion_with_reasoning(self):
# Test non-streaming with "enable_thinking": True, reasoning_content should not be empty
client = requests.post(
f"{self.base_url}/v1/chat/completions",
headers={"Authorization": f"Bearer {self.api_key}"},
json={
"model": self.model,
"messages": [{"role": "user", "content": "Hello"}],
"temperature": 0,
"separate_reasoning": True,
"chat_template_kwargs": {"enable_thinking": True},
**self.additional_chat_kwargs,
},
)
self.assertEqual(client.status_code, 200, f"Failed with: {client.text}")
data = client.json()
self.assertIn("choices", data)
self.assertTrue(len(data["choices"]) > 0)
self.assertIn("message", data["choices"][0])
self.assertIn("reasoning_content", data["choices"][0]["message"])
self.assertIsNotNone(data["choices"][0]["message"]["reasoning_content"])
def test_chat_completion_without_reasoning(self):
# Test non-streaming with "enable_thinking": False, reasoning_content should be empty
client = requests.post(
f"{self.base_url}/v1/chat/completions",
headers={"Authorization": f"Bearer {self.api_key}"},
json={
"model": self.model,
"messages": [{"role": "user", "content": "Hello"}],
"temperature": 0,
"separate_reasoning": True,
"chat_template_kwargs": {"enable_thinking": False},
**self.additional_chat_kwargs,
},
)
self.assertEqual(client.status_code, 200, f"Failed with: {client.text}")
data = client.json()
self.assertIn("choices", data)
self.assertTrue(len(data["choices"]) > 0)
self.assertIn("message", data["choices"][0])
if "reasoning_content" in data["choices"][0]["message"]:
self.assertIsNone(data["choices"][0]["message"]["reasoning_content"])
def test_stream_chat_completion_with_reasoning(self):
# Test streaming with "enable_thinking": True, reasoning_content should not be empty
response = requests.post(
f"{self.base_url}/v1/chat/completions",
headers={"Authorization": f"Bearer {self.api_key}"},
json={
"model": self.model,
"messages": [{"role": "user", "content": "Hello"}],
"temperature": 0,
"separate_reasoning": True,
"stream": True,
"chat_template_kwargs": {"enable_thinking": True},
**self.additional_chat_kwargs,
},
stream=True,
)
self.assertEqual(response.status_code, 200, f"Failed with: {response.text}")
has_reasoning = False
has_content = False
print("\n=== Stream With Reasoning ===")
for line in response.iter_lines():
if line:
line = line.decode("utf-8")
if line.startswith("data:") and not line.startswith("data: [DONE]"):
data = json.loads(line[6:])
if "choices" in data and len(data["choices"]) > 0:
delta = data["choices"][0].get("delta", {})
if "reasoning_content" in delta and delta["reasoning_content"]:
has_reasoning = True
if "content" in delta and delta["content"]:
has_content = True
self.assertTrue(
has_reasoning,
"The reasoning content is not included in the stream response",
)
self.assertTrue(
has_content, "The stream response does not contain normal content"
)
def test_stream_chat_completion_without_reasoning(self):
# Test streaming with "enable_thinking": False, reasoning_content should be empty
response = requests.post(
f"{self.base_url}/v1/chat/completions",
headers={"Authorization": f"Bearer {self.api_key}"},
json={
"model": self.model,
"messages": [{"role": "user", "content": "Hello"}],
"temperature": 0,
"separate_reasoning": True,
"stream": True,
"chat_template_kwargs": {"enable_thinking": False},
**self.additional_chat_kwargs,
},
stream=True,
)
self.assertEqual(response.status_code, 200, f"Failed with: {response.text}")
has_reasoning = False
has_content = False
print("\n=== Stream Without Reasoning ===")
for line in response.iter_lines():
if line:
line = line.decode("utf-8")
if line.startswith("data:") and not line.startswith("data: [DONE]"):
data = json.loads(line[6:])
if "choices" in data and len(data["choices"]) > 0:
delta = data["choices"][0].get("delta", {})
if "reasoning_content" in delta and delta["reasoning_content"]:
has_reasoning = True
if "content" in delta and delta["content"]:
has_content = True
self.assertFalse(
has_reasoning,
"The reasoning content should not be included in the stream response",
)
self.assertTrue(
has_content, "The stream response does not contain normal content"
)
if __name__ == "__main__":
unittest.main()

92
test/registered/ascend/basic_function/parameter/test_ascend_log_level.py Normal file
View File

@@ -0,0 +1,92 @@
import os
import unittest
import requests
from sglang.srt.utils import kill_process_tree
from sglang.test.ascend.test_ascend_utils import LLAMA_3_2_1B_INSTRUCT_WEIGHTS_PATH
from sglang.test.ci.ci_register import register_npu_ci
from sglang.test.test_utils import (
DEFAULT_TIMEOUT_FOR_SERVER_LAUNCH,
DEFAULT_URL_FOR_TEST,
CustomTestCase,
popen_launch_server,
)
register_npu_ci(est_time=400, suite="nightly-1-npu-a3", nightly=True)
class TestLogLevel(CustomTestCase):
"""Testcase：Verify set log-level parameter, the printed log level is the same as the configured log level and the inference request is successfully processed.
[Test Category] Parameter
[Test Target] --log-level
"""
model = LLAMA_3_2_1B_INSTRUCT_WEIGHTS_PATH
OUT_LOG_PATH = "./out_log.txt"
ERR_LOG_PATH = "./err_log.txt"
def _launch_server_and_run_infer(self, other_args):
out_log_file = None
err_log_file = None
process = None
try:
out_log_file = open(self.OUT_LOG_PATH, "w+", encoding="utf-8")
err_log_file = open(self.ERR_LOG_PATH, "w+", encoding="utf-8")
process = popen_launch_server(
self.model,
DEFAULT_URL_FOR_TEST,
timeout=DEFAULT_TIMEOUT_FOR_SERVER_LAUNCH,
other_args=other_args,
return_stdout_stderr=(out_log_file, err_log_file),
)
health_resp = requests.get(f"{DEFAULT_URL_FOR_TEST}/health_generate")
self.assertEqual(health_resp.status_code, 200)
gen_resp = requests.post(
f"{DEFAULT_URL_FOR_TEST}/generate",
json={
"text": "The capital of France is",
"sampling_params": {"temperature": 0, "max_new_tokens": 32},
},
)
self.assertEqual(gen_resp.status_code, 200)
self.assertIn("Paris", gen_resp.text)
out_log_file.seek(0)
return out_log_file.read()
finally:
kill_process_tree(process.pid)
out_log_file.close()
err_log_file.close()
os.remove(self.OUT_LOG_PATH)
os.remove(self.ERR_LOG_PATH)
def test_log_level(self):
# Verify set --log-level=warning and not set --log-level-http, logs print only warning level (no HTTP info)
other_args = [
"--log-level",
"warning",
"--attention-backend",
"ascend",
"--disable-cuda-graph",
]
log_content = self._launch_server_and_run_infer(other_args)
self.assertNotIn("POST /generate HTTP/1.1", log_content)
def test_log_http_level(self):
# Verify set --log-level=warning and set --log-level-http=info, log level print http info
other_args = [
"--log-level",
"warning",
"--log-level-http",
"info",
"--attention-backend",
"ascend",
"--disable-cuda-graph",
]
log_content = self._launch_server_and_run_infer(other_args)
self.assertIn("POST /generate HTTP/1.1", log_content)
if __name__ == "__main__":
unittest.main()

39
test/registered/ascend/basic_function/parameter/test_ascend_no_chunked_prefill.py Normal file
View File

@@ -0,0 +1,39 @@
import unittest
from sglang.test.ascend.test_ascend_utils import LLAMA_3_1_8B_INSTRUCT_WEIGHTS_PATH
from sglang.test.ci.ci_register import register_npu_ci
from sglang.test.test_utils import CustomTestCase, run_bench_serving, run_mmlu_test
register_npu_ci(
est_time=400,
suite="nightly-1-npu-a3",
nightly=True,
disabled="run failed",
)
class TestNoChunkedPrefill(CustomTestCase):
"""Testcase: Verify Llama-3.1-8B-Instruct accuracy ≥ 0.65 and serving normal with chunked prefill disabled.
[Test Category] Parameter
[Test Target] --chunked-prefill-size
"""
def test_no_chunked_prefill(self):
run_mmlu_test(
disable_radix_cache=False, enable_mixed_chunk=False, chunked_prefill_size=-1
)
def test_no_chunked_prefill_without_radix_cache(self):
res = run_bench_serving(
model=LLAMA_3_1_8B_INSTRUCT_WEIGHTS_PATH,
num_prompts=10,
request_rate=float("inf"),
other_server_args=["--disable-radix-cache", "--chunked-prefill-size", "-1"],
)
assert res["completed"] == 10
if __name__ == "__main__":
unittest.main()

48
test/registered/ascend/basic_function/parameter/test_ascend_no_overlap_scheduler.py Normal file
View File

@@ -0,0 +1,48 @@
import unittest
from sglang.test.ci.ci_register import register_npu_ci
from sglang.test.test_utils import CustomTestCase, run_mmlu_test
register_npu_ci(
est_time=400,
suite="nightly-1-npu-a3",
nightly=True,
disabled="run failed",
)
class TestOverlapSchedule(CustomTestCase):
"""Testcase: Verify that the model can successfully process inference requests and achieve an accuracy of ≥ 0.65 when the overlap scheduler is disabled,
covering all combination scenarios of radix cache (enabled/disabled) and chunked prefill (enabled/disabled).
[Test Category] Parameter
[Test Target] --disable-radix-cache;--disable-overlap
"""
def test_no_radix_attention_chunked_prefill(self):
run_mmlu_test(
disable_radix_cache=True,
chunked_prefill_size=128,
disable_overlap=True,
)
def test_no_radix_attention_no_chunked_prefill(self):
run_mmlu_test(
disable_radix_cache=True, chunked_prefill_size=-1, disable_overlap=True
)
def test_radix_attention_chunked_prefill(self):
run_mmlu_test(
disable_radix_cache=False,
chunked_prefill_size=128,
disable_overlap=True,
)
def test_radix_attention_no_chunked_prefill(self):
run_mmlu_test(
disable_radix_cache=False, chunked_prefill_size=-1, disable_overlap=True
)
if __name__ == "__main__":
unittest.main()

208
test/registered/ascend/basic_function/parameter/test_ascend_original_logprobs.py Normal file
View File

@@ -0,0 +1,208 @@
"""Test original log probability alignment between SGLang and Hugging Face.
This test suite verifies the correctness of the `origin_logprobs` output (temperature=1)
and the `logprobs` output (temperature=0.5) in SGLang by comparing it against
raw logit-based probabilities computed directly from a reference Hugging Face model.
The test covers the following scenarios:
- Next-token prediction: Verifies that the log probability of the next token from
SGLang matches the Hugging Face model.
- Top-k logprobs: Ensures that the top-k original logprobs returned by SGLang are
consistent with Hugging Face outputs.
- Specified token IDs: Confirms that the original logprobs for specific token IDs
match the values computed from Hugging Face logits.
"""
import os
import random
import unittest
import torch
import torch.nn.functional as F
from transformers import AutoModelForCausalLM, AutoTokenizer
import sglang as sgl
from sglang.test.ascend.test_ascend_utils import LLAMA_3_2_1B_INSTRUCT_WEIGHTS_PATH
from sglang.test.ci.ci_register import register_npu_ci
# ------------------------- Configurable via env ------------------------- #
MODEL_ID = LLAMA_3_2_1B_INSTRUCT_WEIGHTS_PATH
PROMPTS = [
"Hello, my name is",
"The future of AI is",
"The president of the United States is",
"The capital of France is ",
]
TOP_LOGPROBS_NUM = 50
NUM_RANDOM_TOKEN_IDS = 10
RTOL = 0.20
ATOL = 0.00
# ------------------------------------------------
torch.manual_seed(1234)
if torch.cuda.is_available():
torch.cuda.manual_seed_all(1234)
torch.backends.cuda.matmul.allow_tf32 = False
torch.backends.cudnn.allow_tf32 = False
register_npu_ci(est_time=400, suite="nightly-1-npu-a3", nightly=True)
class TestOriginalLogprob(unittest.TestCase):
"""Testcase: Verify the behavior and log probability alignment of SGLang under two configurations of the environment variable `SGLANG_RETURN_ORIGINAL_LOGPROB` (True/False),
by comparing SGLang's output with reference values from Hugging Face.
[Test Category] Parameter
[Test Target] SGLANG_RETURN_ORIGINAL_LOGPROB
"""
def setUp(self):
# ----- HF side (float32 weights) -----
self.tokenizer = AutoTokenizer.from_pretrained(MODEL_ID, padding_side="right")
self.hf_model = AutoModelForCausalLM.from_pretrained(
MODEL_ID, torch_dtype=torch.float32, device_map="auto"
)
# Shared sampling parameters
self.sampling_params = {
"temperature": 0.5, # SGLang uses 0.5, but original logprobs are used 1.0
"top_p": 1.0,
"top_k": 10,
"max_new_tokens": 1,
}
# ---------------------------------------------------------------------
# Helper: compare one SGLang block (token_logprobs / top_logprobs / ids_logprobs)
# against a reference HF log‑prob vector.
# ---------------------------------------------------------------------
def assert_logprobs_block_equal(
self,
hf_log_probs: torch.Tensor, # [V]
token_log_probs: list,
top_log_probs: list,
ids_log_probs: list,
random_token_ids: list,
tag: str = "",
):
vals, idxs, _ = zip(*token_log_probs)
sgl_vals = torch.tensor(vals, device=self.hf_model.device, dtype=torch.float32)
sgl_idxs = torch.tensor(idxs, device=self.hf_model.device, dtype=torch.long)
hf_vals = hf_log_probs[sgl_idxs]
self.assertTrue(
torch.allclose(hf_vals, sgl_vals, rtol=RTOL, atol=ATOL),
msg=f"[{tag}] token‑level mismatch at indices {sgl_idxs.tolist()}",
)
hf_topk, _ = torch.topk(hf_log_probs, k=TOP_LOGPROBS_NUM, dim=-1)
sgl_topk = torch.tensor(
[float(t[0]) for t in top_log_probs[0] if t and t[0] is not None][
:TOP_LOGPROBS_NUM
],
dtype=torch.float32,
device=self.hf_model.device,
)
k = min(hf_topk.numel(), sgl_topk.numel())
self.assertTrue(
torch.allclose(hf_topk[:k], sgl_topk[:k], rtol=RTOL, atol=ATOL),
msg=f"[{tag}] top‑k mismatch",
)
indices = torch.tensor(
random_token_ids, dtype=torch.long, device=hf_log_probs.device
)
hf_token_ids = hf_log_probs[indices]
sgl_token_ids = torch.tensor(
[v for v, _, _ in ids_log_probs[0]],
device=self.hf_model.device,
dtype=torch.float32,
)
self.assertTrue(
torch.allclose(hf_token_ids, sgl_token_ids, rtol=RTOL, atol=ATOL),
msg=f"[{tag}] token‑IDs mismatch",
)
# Optional: print max abs diff for quick diagnostics
max_diff = torch.max(torch.abs(hf_vals - sgl_vals)).item()
print(f"[{tag}] max|diff| token‑level = {max_diff:.4f}")
def test_logprob_match(self):
vocab_size = self.tokenizer.vocab_size
for env_val in ["True", "False"]:
with self.subTest(return_original_logprob=env_val):
os.environ["SGLANG_RETURN_ORIGINAL_LOGPROB"] = env_val
# ----- SGLang side -----
sgl_engine = sgl.Engine(
model_path=MODEL_ID,
skip_tokenizer_init=True,
trust_remote_code=True,
mem_fraction_static=0.60,
attention_backend="ascend",
disable_cuda_graph=True,
)
for prompt in PROMPTS:
random_token_ids = sorted(
random.sample(range(vocab_size), NUM_RANDOM_TOKEN_IDS)
)
enc = self.tokenizer(prompt, return_tensors="pt")
input_ids = enc["input_ids"].to(self.hf_model.device)
attn_mask = enc["attention_mask"].to(self.hf_model.device)
with torch.inference_mode():
hf_out = self.hf_model(
input_ids=input_ids,
attention_mask=attn_mask,
return_dict=True,
)
logits = hf_out.logits[:, -1, :] # [1, V]
hf_log_probs = F.log_softmax(
logits.float() / self.sampling_params["temperature"], dim=-1
)[0]
hf_original_log_probs = F.log_softmax(logits.float(), dim=-1)[0]
outputs = sgl_engine.generate(
input_ids=input_ids[0].tolist(),
sampling_params=self.sampling_params,
return_logprob=True,
top_logprobs_num=TOP_LOGPROBS_NUM,
token_ids_logprob=random_token_ids,
)
if isinstance(outputs, list):
outputs = outputs[0]
meta = outputs["meta_info"]
# Check original logprobs only if enabled
if env_val.lower() == "true":
self.assert_logprobs_block_equal(
hf_log_probs=hf_original_log_probs,
token_log_probs=meta["output_token_logprobs"],
top_log_probs=meta["output_top_logprobs"],
ids_log_probs=meta["output_token_ids_logprobs"],
random_token_ids=random_token_ids,
tag=f"Original logprobs SGLang vs HF: {prompt} ({env_val})",
)
else:
# Always check regular logprobs
self.assert_logprobs_block_equal(
hf_log_probs=hf_log_probs,
token_log_probs=meta["output_token_logprobs"],
top_log_probs=meta["output_top_logprobs"],
ids_log_probs=meta["output_token_ids_logprobs"],
random_token_ids=random_token_ids,
tag=f"logprobs SGLang vs HF: {prompt} ({env_val})",
)
sgl_engine.shutdown()
if __name__ == "__main__":
unittest.main()

92
test/registered/ascend/basic_function/parameter/test_ascend_warmups.py Normal file
View File

@@ -0,0 +1,92 @@
import os
import unittest
import requests
from sglang.srt.utils import kill_process_tree
from sglang.test.ascend.test_ascend_utils import MINICPM_O_2_6_WEIGHTS_PATH
from sglang.test.ci.ci_register import register_npu_ci
from sglang.test.test_utils import (
DEFAULT_URL_FOR_TEST,
CustomTestCase,
popen_launch_server,
)
register_npu_ci(
est_time=400,
suite="nightly-4-npu-a3",
nightly=True,
disabled="run failed",
)
class TestAscendWarmups(CustomTestCase):
"""Testcase: Test that the warm-up task runs successfully when the --warmups voice_chat parameter is specified upon service startup.
[Test Category] Parameter
[Test Target] --warmups
"""
model = MINICPM_O_2_6_WEIGHTS_PATH
base_url = DEFAULT_URL_FOR_TEST
@classmethod
def setUpClass(cls):
other_args = [
"--trust-remote-code",
"--warmups",
"voice_chat",
"--tp-size",
"4",
"--mem-fraction-static",
"0.8",
"--attention-backend",
"ascend",
"--disable-cuda-graph",
]
cls.out_log_file = open("./out_log.txt", "w+", encoding="utf-8")
cls.err_log_file = open("./err_log.txt", "w+", encoding="utf-8")
cls.process = popen_launch_server(
cls.model,
cls.base_url,
timeout=3600,
other_args=other_args,
return_stdout_stderr=(cls.out_log_file, cls.err_log_file),
)
@classmethod
def tearDownClass(cls):
kill_process_tree(cls.process.pid)
cls.out_log_file.close()
cls.err_log_file.close()
os.remove("./out_log.txt")
os.remove("./err_log.txt")
def test_warmups_with_voice_chat(self):
# Call the get_server_info API to verify that the warmups parameter configuration takes effect.
response = requests.get(f"{DEFAULT_URL_FOR_TEST}/get_server_info")
self.assertEqual(response.status_code, 200)
self.assertEqual("voice_chat", response.json().get("warmups"))
# Verify the actual execution of the warm-up task.
self.err_log_file.seek(0)
content = self.err_log_file.read()
self.assertIn("Running warmup voice_chat", content)
# Verify that the inference API functions properly.
response = requests.post(
f"{DEFAULT_URL_FOR_TEST}/generate",
json={
"text": "The capital of France is",
"sampling_params": {
"temperature": 0,
"max_new_tokens": 32,
},
},
)
self.assertEqual(response.status_code, 200)
self.assertIn("Paris", response.text)
if __name__ == "__main__":
unittest.main()

13
test/registered/ascend/llm_models/test_ascend_afm_4_5b.py
View File

@@ -1,15 +1,22 @@
import unittest
from sglang.test.ascend.gsm8k_ascend_mixin import GSM8KAscendMixin
from sglang.test.ascend.test_ascend_utils import AFM_4_5B_BASE_WEIGHTS_PATH
from sglang.test.ci.ci_register import register_npu_ci
from sglang.test.test_utils import CustomTestCase
register_npu_ci(est_time=400, suite="nightly-1-npu-a3", nightly=True)
class TestMistral7B(GSM8KAscendMixin, CustomTestCase):
model = "/root/.cache/modelscope/hub/models/arcee-ai/AFM-4.5B-Base"
accuracy = 0.00
class TestAFM(GSM8KAscendMixin, CustomTestCase):
"""Testcase: Verify that the inference accuracy of the arcee-ai/AFM-4.5B-Base model on the GSM8K dataset is no less than 0.375.
[Test Category] Model
[Test Target] arcee-ai/AFM-4.5B-Base
"""
model = AFM_4_5B_BASE_WEIGHTS_PATH
accuracy = 0.375
if __name__ == "__main__":

9
test/registered/ascend/llm_models/test_ascend_baichuan2_13b_chat.py
View File

@@ -1,6 +1,7 @@
import unittest
from sglang.test.ascend.gsm8k_ascend_mixin import GSM8KAscendMixin
from sglang.test.ascend.test_ascend_utils import BAICHUAN2_13B_CHAT_WEIGHTS_PATH
from sglang.test.ci.ci_register import register_npu_ci
from sglang.test.test_utils import CustomTestCase
@@ -8,7 +9,13 @@ register_npu_ci(est_time=400, suite="nightly-1-npu-a3", nightly=True)
class TestBaichuan(GSM8KAscendMixin, CustomTestCase):
model = "/root/.cache/modelscope/hub/models/baichuan-inc/Baichuan2-13B-Chat"
"""Testcase: Verify that the inference accuracy of the baichuan-inc/Baichuan2-13B-Chat model on the GSM8K dataset is no less than 0.48.
[Test Category] Model
[Test Target] baichuan-inc/Baichuan2-13B-Chat
"""
model = BAICHUAN2_13B_CHAT_WEIGHTS_PATH
accuracy = 0.48
other_args = [
"--trust-remote-code",

11
test/registered/ascend/llm_models/test_ascend_charglm2_6b.py
View File

@@ -1,14 +1,21 @@
import unittest
from sglang.test.ascend.gsm8k_ascend_mixin import GSM8KAscendMixin
from sglang.test.ascend.test_ascend_utils import CHATGLM2_6B_WEIGHTS_PATH
from sglang.test.ci.ci_register import register_npu_ci
from sglang.test.test_utils import CustomTestCase
register_npu_ci(est_time=400, suite="nightly-1-npu-a3", nightly=True)
class TestMistral7B(GSM8KAscendMixin, CustomTestCase):
model = "/root/.cache/modelscope/hub/models/ZhipuAI/chatglm2-6b"
class TestChatGlm2(GSM8KAscendMixin, CustomTestCase):
"""Testcase: Verify that the inference accuracy of the ZhipuAI/chatglm2-6b model on the GSM8K dataset is no less than 0.25.
[Test Category] Model
[Test Target] ZhipuAI/chatglm2-6b
"""
model = CHATGLM2_6B_WEIGHTS_PATH
accuracy = 0.25
other_args = [
"--trust-remote-code",

21
test/registered/ascend/llm_models/test_ascend_deepseek_v3_2_exp_w8a8.py
View File

@@ -1,15 +1,28 @@
import unittest
from sglang.test.ascend.gsm8k_ascend_mixin import GSM8KAscendMixin
from sglang.test.ascend.test_ascend_utils import DEEPSEEK_V3_2_EXP_W8A8_WEIGHTS_PATH
from sglang.test.ci.ci_register import register_npu_ci
from sglang.test.test_utils import CustomTestCase
register_npu_ci(est_time=400, suite="nightly-16-npu-a3", nightly=True)
register_npu_ci(
est_time=400,
suite="nightly-16-npu-a3",
nightly=True,
disabled="run failed",
)
class TestDeepSeekV3_2ExpW8A8(GSM8KAscendMixin, CustomTestCase):
model = "/root/.cache/modelscope/hub/models/DeepSeek-V3.2-Exp-W8A8"
accuracy = 0.51
class TestDeepSeekV32(GSM8KAscendMixin, CustomTestCase):
"""Testcase: Verify that the inference accuracy of the vllm-ascend/DeepSeek-V3.2-Exp-W8A8 model on the GSM8K dataset is no less than 0.5.
[Test Category] Model
[Test Target] vllm-ascend/DeepSeek-V3.2-Exp-W8A8
"""
model = DEEPSEEK_V3_2_EXP_W8A8_WEIGHTS_PATH
accuracy = 0.5
timeout_for_server_launch = 3000
other_args = [
"--trust-remote-code",
"--mem-fraction-static",

13
test/registered/ascend/llm_models/test_ascend_exaone_3.py
View File

@@ -1,15 +1,22 @@
import unittest
from sglang.test.ascend.gsm8k_ascend_mixin import GSM8KAscendMixin
from sglang.test.ascend.test_ascend_utils import EXAONE_3_5_7_8B_INSTRUCT_WEIGHTS_PATH
from sglang.test.ci.ci_register import register_npu_ci
from sglang.test.test_utils import CustomTestCase
register_npu_ci(est_time=400, suite="nightly-1-npu-a3", nightly=True)
class TestMistral7B(GSM8KAscendMixin, CustomTestCase):
model = "/root/.cache/modelscope/hub/models/LGAI-EXAONE/EXAONE-3.5-7.8B-Instruct"
accuracy = 0.00
class TestEXAONE(GSM8KAscendMixin, CustomTestCase):
"""Testcase: Verify that the inference accuracy of the LGAI-EXAONE/EXAONE-3.5-7.8B-Instruct model on the GSM8K dataset is no less than 0.8.
[Test Category] Model
[Test Target] LGAI-EXAONE/EXAONE-3.5-7.8B-Instruct
"""
model = EXAONE_3_5_7_8B_INSTRUCT_WEIGHTS_PATH
accuracy = 0.8
other_args = [
"--trust-remote-code",
"--mem-fraction-static",

18
test/registered/ascend/llm_models/test_ascend_glm4_9b_chat.py
View File

@@ -1,15 +1,27 @@
import unittest
from sglang.test.ascend.gsm8k_ascend_mixin import GSM8KAscendMixin
from sglang.test.ascend.test_ascend_utils import GLM_4_9B_CHAT_WEIGHTS_PATH
from sglang.test.ci.ci_register import register_npu_ci
from sglang.test.test_utils import CustomTestCase
register_npu_ci(est_time=400, suite="nightly-1-npu-a3", nightly=True)
register_npu_ci(
est_time=400,
suite="nightly-1-npu-a3",
nightly=True,
disabled="run failed",
)
class TestGLM49BChat(GSM8KAscendMixin, CustomTestCase):
model = "/root/.cache/modelscope/hub/models/ZhipuAI/glm-4-9b-chat"
accuracy = 0.00
"""Testcase: Verify that the inference accuracy of the ZhipuAI/glm-4-9b-chat model on the GSM8K dataset is no less than 0.79.
[Test Category] Model
[Test Target] ZhipuAI/glm-4-9b-chat
"""
model = GLM_4_9B_CHAT_WEIGHTS_PATH
accuracy = 0.79
if __name__ == "__main__":

17
test/registered/ascend/llm_models/test_ascend_granite_3_0_3b_a800m.py
View File

@@ -1,17 +1,24 @@
import unittest
from sglang.test.ascend.gsm8k_ascend_mixin import GSM8KAscendMixin
from sglang.test.ascend.test_ascend_utils import (
GRANITE_3_0_3B_A800M_INSTRUCT_WEIGHTS_PATH,
)
from sglang.test.ci.ci_register import register_npu_ci
from sglang.test.test_utils import CustomTestCase
register_npu_ci(est_time=400, suite="nightly-1-npu-a3", nightly=True)
class TestMistral7B(GSM8KAscendMixin, CustomTestCase):
model = (
"/root/.cache/modelscope/hub/models/ibm-granite/granite-3.0-3b-a800m-instruct"
)
accuracy = 0.00
class TestGranite(GSM8KAscendMixin, CustomTestCase):
"""Testcase: Verify that the inference accuracy of the ibm-granite/granite-3.0-3b-a800m-instruct model on the GSM8K dataset is no less than 0.38.
[Test Category] Model
[Test Target] ibm-granite/granite-3.0-3b-a800m-instruct
"""
model = GRANITE_3_0_3B_A800M_INSTRUCT_WEIGHTS_PATH
accuracy = 0.38
if __name__ == "__main__":

11
test/registered/ascend/llm_models/test_ascend_granite_3_1_8b.py
View File

@@ -1,14 +1,21 @@
import unittest
from sglang.test.ascend.gsm8k_ascend_mixin import GSM8KAscendMixin
from sglang.test.ascend.test_ascend_utils import GRANITE_3_1_8B_INSTRUCT_WEIGHTS_PATH
from sglang.test.ci.ci_register import register_npu_ci
from sglang.test.test_utils import CustomTestCase
register_npu_ci(est_time=400, suite="nightly-1-npu-a3", nightly=True)
class TestMistral7B(GSM8KAscendMixin, CustomTestCase):
model = "/root/.cache/modelscope/hub/models/ibm-granite/granite-3.1-8b-instruct"
class TestGranite(GSM8KAscendMixin, CustomTestCase):
"""Testcase: Verify that the inference accuracy of the ibm-granite/granite-3.1-8b-instruct model on the GSM8K dataset is no less than 0.695.
[Test Category] Model
[Test Target] ibm-granite/granite-3.1-8b-instruct
"""
model = GRANITE_3_1_8B_INSTRUCT_WEIGHTS_PATH
accuracy = 0.695

13
test/registered/ascend/llm_models/test_ascend_internlm2_7b.py
View File

@@ -1,15 +1,22 @@
import unittest
from sglang.test.ascend.gsm8k_ascend_mixin import GSM8KAscendMixin
from sglang.test.ascend.test_ascend_utils import INTERNLM2_7B_WEIGHTS_PATH
from sglang.test.ci.ci_register import register_npu_ci
from sglang.test.test_utils import CustomTestCase
register_npu_ci(est_time=400, suite="nightly-1-npu-a3", nightly=True)
class TestMistral7B(GSM8KAscendMixin, CustomTestCase):
model = "/root/.cache/modelscope/hub/models/Shanghai_AI_Laboratory/internlm2-7b"
accuracy = 0.6
class TestInternlm2(GSM8KAscendMixin, CustomTestCase):
"""Testcase: Verify that the inference accuracy of the Shanghai_AI_Laboratory/internlm2-7b model on the GSM8K dataset is no less than 0.585.
[Test Category] Model
[Test Target] Shanghai_AI_Laboratory/internlm2-7b
"""
model = INTERNLM2_7B_WEIGHTS_PATH
accuracy = 0.585
if __name__ == "__main__":

23
test/registered/ascend/llm_models/test_ascend_ling_lite.py
View File

@@ -1,15 +1,32 @@
import unittest
from sglang.test.ascend.gsm8k_ascend_mixin import GSM8KAscendMixin
from sglang.test.ascend.test_ascend_utils import LING_LITE_WEIGHTS_PATH
from sglang.test.ci.ci_register import register_npu_ci
from sglang.test.test_utils import CustomTestCase
register_npu_ci(est_time=400, suite="nightly-1-npu-a3", nightly=True)
register_npu_ci(est_time=400, suite="nightly-2-npu-a3", nightly=True)
class TestMistral7B(GSM8KAscendMixin, CustomTestCase):
model = "/root/.cache/modelscope/hub/models/inclusionAI/Ling-lite"
class TestLingLite(GSM8KAscendMixin, CustomTestCase):
"""Testcase: Verify that the inference accuracy of the inclusionAI/Ling-lite model on the GSM8K dataset is no less than 0.75.
[Test Category] Model
[Test Target] inclusionAI/Ling-lite
"""
model = LING_LITE_WEIGHTS_PATH
accuracy = 0.75
other_args = [
"--trust-remote-code",
"--mem-fraction-static",
"0.8",
"--attention-backend",
"ascend",
"--disable-cuda-graph",
"--tp-size",
"2",
]
if __name__ == "__main__":

11
test/registered/ascend/llm_models/test_ascend_llama_2_7b.py
View File

@@ -1,14 +1,21 @@
import unittest
from sglang.test.ascend.gsm8k_ascend_mixin import GSM8KAscendMixin
from sglang.test.ascend.test_ascend_utils import LLAMA_2_7B_WEIGHTS_PATH
from sglang.test.ci.ci_register import register_npu_ci
from sglang.test.test_utils import CustomTestCase
register_npu_ci(est_time=400, suite="nightly-1-npu-a3", nightly=True)
class TestMistral7B(GSM8KAscendMixin, CustomTestCase):
model = "/root/.cache/modelscope/hub/models/LLM-Research/Llama-2-7B"
class TestLlama(GSM8KAscendMixin, CustomTestCase):
"""Testcase: Verify that the inference accuracy of the LLM-Research/Llama-2-7B model on the GSM8K dataset is no less than 0.18.
[Test Category] Model
[Test Target] LLM-Research/Llama-2-7B
"""
model = LLAMA_2_7B_WEIGHTS_PATH
accuracy = 0.18

11
test/registered/ascend/llm_models/test_ascend_mimo_7b_rl.py
View File

@@ -1,14 +1,21 @@
import unittest
from sglang.test.ascend.gsm8k_ascend_mixin import GSM8KAscendMixin
from sglang.test.ascend.test_ascend_utils import MIMO_7B_RL_WEIGHTS_PATH
from sglang.test.ci.ci_register import register_npu_ci
from sglang.test.test_utils import CustomTestCase
register_npu_ci(est_time=400, suite="nightly-1-npu-a3", nightly=True)
class TestMistral7B(GSM8KAscendMixin, CustomTestCase):
model = "/root/.cache/modelscope/hub/models/XiaomiMiMo/MiMo-7B-RL"
class TestMiMo7BRL(GSM8KAscendMixin, CustomTestCase):
"""Testcase: Verify that the inference accuracy of the XiaomiMiMo/MiMo-7B-RL model on the GSM8K dataset is no less than 0.75.
[Test Category] Model
[Test Target] XiaomiMiMo/MiMo-7B-RL
"""
model = MIMO_7B_RL_WEIGHTS_PATH
accuracy = 0.75

16
test/registered/ascend/llm_models/test_ascend_minicpm3_4b.py
View File

@@ -1,14 +1,26 @@
import unittest
from sglang.test.ascend.gsm8k_ascend_mixin import GSM8KAscendMixin
from sglang.test.ascend.test_ascend_utils import MINICPM3_4B_WEIGHTS_PATH
from sglang.test.ci.ci_register import register_npu_ci
from sglang.test.test_utils import CustomTestCase
register_npu_ci(est_time=400, suite="nightly-1-npu-a3", nightly=True)
register_npu_ci(
est_time=400,
suite="nightly-1-npu-a3",
nightly=True,
disabled="run failed",
)
class TestMiniCPM3(GSM8KAscendMixin, CustomTestCase):
model = "/root/.cache/modelscope/hub/models/OpenBMB/MiniCPM3-4B"
"""Testcase: Verify that the inference accuracy of the OpenBMB/MiniCPM3-4B model on the GSM8K dataset is no less than 0.69.
[Test Category] Model
[Test Target] OpenBMB/MiniCPM3-4B
"""
model = MINICPM3_4B_WEIGHTS_PATH
accuracy = 0.69
other_args = [
"--trust-remote-code",

9
test/registered/ascend/llm_models/test_ascend_mistral_7b.py
View File

@@ -1,6 +1,7 @@
import unittest
from sglang.test.ascend.gsm8k_ascend_mixin import GSM8KAscendMixin
from sglang.test.ascend.test_ascend_utils import MISTRAL_7B_INSTRUCT_V0_2_WEIGHTS_PATH
from sglang.test.ci.ci_register import register_npu_ci
from sglang.test.test_utils import CustomTestCase
@@ -8,7 +9,13 @@ register_npu_ci(est_time=400, suite="nightly-1-npu-a3", nightly=True)
class TestMistral7B(GSM8KAscendMixin, CustomTestCase):
model = "/root/.cache/modelscope/hub/models/mistralai/Mistral-7B-Instruct-v0.2"
"""Testcase: Verify that the inference accuracy of the mistralai/Mistral-7B-Instruct-v0.2 model on the GSM8K dataset is no less than 0.375.
[Test Category] Model
[Test Target] mistralai/Mistral-7B-Instruct-v0.2
"""
model = MISTRAL_7B_INSTRUCT_V0_2_WEIGHTS_PATH
accuracy = 0.375

11
test/registered/ascend/llm_models/test_ascend_persimmon_8b_chat.py
View File

@@ -1,14 +1,21 @@
import unittest
from sglang.test.ascend.gsm8k_ascend_mixin import GSM8KAscendMixin
from sglang.test.ascend.test_ascend_utils import PERSIMMON_8B_CHAT_WEIGHTS_PATH
from sglang.test.ci.ci_register import register_npu_ci
from sglang.test.test_utils import CustomTestCase
register_npu_ci(est_time=400, suite="nightly-1-npu-a3", nightly=True)
class TestMistral7B(GSM8KAscendMixin, CustomTestCase):
model = "/root/.cache/modelscope/hub/models/Howeee/persimmon-8b-chat"
class TestPersimmon8BChat(GSM8KAscendMixin, CustomTestCase):
"""Testcase: Verify that the inference accuracy of the Howeee/persimmon-8b-chat model on the GSM8K dataset is no less than 0.17.
[Test Category] Model
[Test Target] Howeee/persimmon-8b-chat
"""
model = PERSIMMON_8B_CHAT_WEIGHTS_PATH
accuracy = 0.17

11
test/registered/ascend/llm_models/test_ascend_phi_4_multimodal.py
View File

@@ -1,14 +1,21 @@
import unittest
from sglang.test.ascend.gsm8k_ascend_mixin import GSM8KAscendMixin
from sglang.test.ascend.test_ascend_utils import PHI_4_MULTIMODAL_INSTRUCT_WEIGHTS_PATH
from sglang.test.ci.ci_register import register_npu_ci
from sglang.test.test_utils import CustomTestCase
register_npu_ci(est_time=400, suite="nightly-1-npu-a3", nightly=True)
class TestMistral7B(GSM8KAscendMixin, CustomTestCase):
model = "/root/.cache/modelscope/hub/models/LLM-Research/Phi-4-multimodal-instruct"
class TestPhi4(GSM8KAscendMixin, CustomTestCase):
"""Testcase: Verify that the inference accuracy of the microsoft/Phi-4-multimodal-instruct model on the GSM8K dataset is no less than 0.8.
[Test Category] Model
[Test Target] microsoft/Phi-4-multimodal-instruct
"""
model = PHI_4_MULTIMODAL_INSTRUCT_WEIGHTS_PATH
accuracy = 0.8

30
test/registered/ascend/llm_models/test_ascend_qwen3_0_6b.py Normal file
View File

@@ -0,0 +1,30 @@
import unittest
from sglang.test.ascend.gsm8k_ascend_mixin import GSM8KAscendMixin
from sglang.test.ascend.test_ascend_utils import QWEN3_0_6B_WEIGHTS_PATH
from sglang.test.ci.ci_register import register_npu_ci
from sglang.test.test_utils import CustomTestCase
register_npu_ci(est_time=400, suite="nightly-1-npu-a3", nightly=True)
class TestQwen306B(GSM8KAscendMixin, CustomTestCase):
"""Testcase: Verify that the inference accuracy of the Qwen/Qwen3-0.6B model on the GSM8K dataset is no less than 0.38.
[Test Category] Model
[Test Target] Qwen/Qwen3-0.6B
"""
model = QWEN3_0_6B_WEIGHTS_PATH
accuracy = 0.38
other_args = [
"--chunked-prefill-size",
256,
"--attention-backend",
"ascend",
"--disable-cuda-graph",
]
if __name__ == "__main__":
unittest.main()

35
test/registered/ascend/llm_models/test_ascend_qwen3_235b_a22b_w8a8.py Normal file
View File

@@ -0,0 +1,35 @@
import unittest
from sglang.test.ascend.gsm8k_ascend_mixin import GSM8KAscendMixin
from sglang.test.ascend.test_ascend_utils import QWEN3_235B_A22B_W8A8_WEIGHTS_PATH
from sglang.test.ci.ci_register import register_npu_ci
from sglang.test.test_utils import CustomTestCase
register_npu_ci(est_time=400, suite="nightly-8-npu-a3", nightly=True)
class TestQwen3235BA22BW8A8(GSM8KAscendMixin, CustomTestCase):
"""Testcase: Verify that the inference accuracy of the vllm-ascend/Qwen3-235B-A22B-W8A8 model on the GSM8K dataset is no less than 0.955.
[Test Category] Model
[Test Target] vllm-ascend/Qwen3-235B-A22B-W8A8
"""
model = QWEN3_235B_A22B_W8A8_WEIGHTS_PATH
accuracy = 0.955
other_args = [
"--trust-remote-code",
"--mem-fraction-static",
"0.8",
"--attention-backend",
"ascend",
"--disable-cuda-graph",
"--tp-size",
"8",
"--quantization",
"modelslim",
]
if __name__ == "__main__":
unittest.main()

39
test/registered/ascend/llm_models/test_ascend_qwen3_30b.py Normal file
View File

@@ -0,0 +1,39 @@
import unittest
from sglang.test.ascend.gsm8k_ascend_mixin import GSM8KAscendMixin
from sglang.test.ascend.test_ascend_utils import (
Qwen3_30B_A3B_Instruct_2507_WEIGHTS_PATH,
)
from sglang.test.ci.ci_register import register_npu_ci
from sglang.test.test_utils import CustomTestCase
register_npu_ci(est_time=400, suite="nightly-2-npu-a3", nightly=True)
class TestQwen330B(GSM8KAscendMixin, CustomTestCase):
"""Testcase: Verify that the inference accuracy of the Qwen/Qwen3-30B-A3B-Instruct-2507 model on the GSM8K dataset is no less than 0.90.
[Test Category] Model
[Test Target] Qwen/Qwen3-30B-A3B-Instruct-2507
"""
model = Qwen3_30B_A3B_Instruct_2507_WEIGHTS_PATH
accuracy = 0.90
other_args = [
"--trust-remote-code",
"--mem-fraction-static",
0.7,
"--max-running-requests",
32,
"--attention-backend",
"ascend",
"--disable-cuda-graph",
"--cuda-graph-max-bs",
32,
"--tp-size",
2,
]
if __name__ == "__main__":
unittest.main()

38
test/registered/ascend/llm_models/test_ascend_qwen3_32b.py Normal file
View File

@@ -0,0 +1,38 @@
import unittest
from sglang.test.ascend.gsm8k_ascend_mixin import GSM8KAscendMixin
from sglang.test.ascend.test_ascend_utils import QWEN3_32B_WEIGHTS_PATH
from sglang.test.ci.ci_register import register_npu_ci
from sglang.test.test_utils import CustomTestCase
register_npu_ci(
est_time=400,
suite="nightly-4-npu-a3",
nightly=True,
disabled="run failed",
)
class TestQwen332B(GSM8KAscendMixin, CustomTestCase):
"""Testcase: Verify that the inference accuracy of the Qwen/Qwen3-32B model on the GSM8K dataset is no less than 0.88.
[Test Category] Model
[Test Target] Qwen/Qwen3-32B
"""
model = QWEN3_32B_WEIGHTS_PATH
accuracy = 0.88
other_args = [
"--trust-remote-code",
"--mem-fraction-static",
"0.8",
"--attention-backend",
"ascend",
"--disable-cuda-graph",
"--tp-size",
"4",
]
if __name__ == "__main__":
unittest.main()

43
test/registered/ascend/llm_models/test_ascend_qwen3_coder_480b_a35b.py Normal file
View File

@@ -0,0 +1,43 @@
import unittest
from sglang.test.ascend.gsm8k_ascend_mixin import GSM8KAscendMixin
from sglang.test.ascend.test_ascend_utils import (
QWEN3_CODER_480B_A35B_INSTRUCT_W8A8_QUAROT_WEIGHTS_PATH,
)
from sglang.test.ci.ci_register import register_npu_ci
from sglang.test.test_utils import CustomTestCase
register_npu_ci(
est_time=400,
suite="nightly-16-npu-a3",
nightly=True,
disabled="run failed",
)
class TestQwen3Coder480BA35B(GSM8KAscendMixin, CustomTestCase):
"""Testcase: Verify that the inference accuracy of the Qwen3-Coder-480B-A35B-Instruct-w8a8-QuaRot model on the GSM8K dataset is no less than 0.94.
[Test Category] Model
[Test Target] Qwen3-Coder-480B-A35B-Instruct-w8a8-QuaRot
"""
model = QWEN3_CODER_480B_A35B_INSTRUCT_W8A8_QUAROT_WEIGHTS_PATH
accuracy = 0.94
timeout_for_server_launch = 3000
other_args = [
"--trust-remote-code",
"--mem-fraction-static",
"0.8",
"--attention-backend",
"ascend",
"--disable-cuda-graph",
"--tp-size",
"16",
"--quantization",
"modelslim",
]
if __name__ == "__main__":
unittest.main()

35
test/registered/ascend/llm_models/test_ascend_qwq_32b_w8a8.py Normal file
View File

@@ -0,0 +1,35 @@
import unittest
from sglang.test.ascend.gsm8k_ascend_mixin import GSM8KAscendMixin
from sglang.test.ascend.test_ascend_utils import QWQ_32B_W8A8_WEIGHTS_PATH
from sglang.test.ci.ci_register import register_npu_ci
from sglang.test.test_utils import CustomTestCase
register_npu_ci(est_time=400, suite="nightly-2-npu-a3", nightly=True)
class TestQWQ32BW8A8(GSM8KAscendMixin, CustomTestCase):
"""Testcase: Verify that the inference accuracy of the vllm-ascend/QWQ-32B-W8A8 model on the GSM8K dataset is no less than 0.59.
[Test Category] Model
[Test Target] vllm-ascend/QWQ-32B-W8A8
"""
model = QWQ_32B_W8A8_WEIGHTS_PATH
accuracy = 0.59
other_args = [
"--trust-remote-code",
"--mem-fraction-static",
"0.8",
"--attention-backend",
"ascend",
"--disable-cuda-graph",
"--tp-size",
"2",
"--quantization",
"modelslim",
]
if __name__ == "__main__":
unittest.main()

11
test/registered/ascend/llm_models/test_ascend_smollm_1_7b.py
View File

@@ -1,14 +1,21 @@
import unittest
from sglang.test.ascend.gsm8k_ascend_mixin import GSM8KAscendMixin
from sglang.test.ascend.test_ascend_utils import SMOLLM_1_7B_WEIGHTS_PATH
from sglang.test.ci.ci_register import register_npu_ci
from sglang.test.test_utils import CustomTestCase
register_npu_ci(est_time=400, suite="nightly-1-npu-a3", nightly=True)
class TestMistral7B(GSM8KAscendMixin, CustomTestCase):
model = "/root/.cache/modelscope/hub/models/HuggingFaceTB/SmolLM-1.7B"
class TestSmolLM(GSM8KAscendMixin, CustomTestCase):
"""Testcase: Verify that the inference accuracy of the HuggingFaceTB/SmolLM-1.7B model on the GSM8K dataset is no less than 0.05.
[Test Category] Model
[Test Target] HuggingFaceTB/SmolLM-1.7B
"""
model = SMOLLM_1_7B_WEIGHTS_PATH
accuracy = 0.05
other_args = [
"--trust-remote-code",

9
test/registered/ascend/llm_models/test_ascend_stablelm-2-1_6b.py
View File

@@ -1,6 +1,7 @@
import unittest
from sglang.test.ascend.gsm8k_ascend_mixin import GSM8KAscendMixin
from sglang.test.ascend.test_ascend_utils import STABLELM_2_1_6B_WEIGHTS_PATH
from sglang.test.ci.ci_register import register_npu_ci
from sglang.test.test_utils import CustomTestCase
@@ -8,7 +9,13 @@ register_npu_ci(est_time=400, suite="nightly-1-npu-a3", nightly=True)
class TestStablelm(GSM8KAscendMixin, CustomTestCase):
model = "/root/.cache/modelscope/hub/models/stabilityai/stablelm-2-1_6b"
"""Testcase: Verify that the inference accuracy of the stabilityai/stablelm-2-1_6b model on the GSM8K dataset is no less than 0.195.
[Test Category] Model
[Test Target] stabilityai/stablelm-2-1_6b
"""
model = STABLELM_2_1_6B_WEIGHTS_PATH
accuracy = 0.195
other_args = [
"--trust-remote-code",

7
test/registered/ascend/test_ascend_memory_consumption.py
View File

@@ -17,7 +17,12 @@ from sglang.test.test_utils import (
popen_launch_server,
)
register_npu_ci(est_time=400, suite="nightly-1-npu-a3", nightly=True)
register_npu_ci(
est_time=400,
suite="nightly-1-npu-a3",
nightly=True,
disabled="run failed",
)
if "ASCEND_RT_VISIBLE_DEVICES" not in os.environ:
os.environ["ASCEND_RT_VISIBLE_DEVICES"] = "0,1"

11
test/registered/ascend/vlm_models/test_ascend_deepseek_vl2.py
View File

@@ -1,13 +1,20 @@
import unittest
from sglang.test.ascend.test_ascend_utils import DEEPSEEK_VL2_WEIGHTS_PATH
from sglang.test.ascend.vlm_utils import TestVLMModels
from sglang.test.ci.ci_register import register_npu_ci
register_npu_ci(est_time=400, suite="nightly-4-npu-a3", nightly=True)
class TestGemmaModels(TestVLMModels):
model = "/root/.cache/modelscope/hub/models/deepseek-ai/deepseek-vl2"
class TestDeepseekVl2(TestVLMModels):
"""Testcase: Verify that the inference accuracy of the deepseek-ai/deepseek-vl2 model on the MMMU dataset is no less than 0.2.
[Test Category] Model
[Test Target] deepseek-ai/deepseek-vl2
"""
model = DEEPSEEK_VL2_WEIGHTS_PATH
mmmu_accuracy = 0.2
def test_vlm_mmmu_benchmark(self):

11
test/registered/ascend/vlm_models/test_ascend_gemma_3_4b_it.py
View File

@@ -1,13 +1,20 @@
import unittest
from sglang.test.ascend.test_ascend_utils import GEMMA_3_4B_IT_WEIGHTS_PATH
from sglang.test.ascend.vlm_utils import TestVLMModels
from sglang.test.ci.ci_register import register_npu_ci
register_npu_ci(est_time=400, suite="nightly-4-npu-a3", nightly=True)
class TestGemmaModels(TestVLMModels):
model = "/root/.cache/modelscope/hub/models/google/gemma-3-4b-it"
class TestGemma34bModels(TestVLMModels):
"""Testcase: Verify that the inference accuracy of the google/gemma-3-4b-it model on the MMMU dataset is no less than 0.2.
[Test Category] Model
[Test Target] google/gemma-3-4b-it
"""
model = GEMMA_3_4B_IT_WEIGHTS_PATH
mmmu_accuracy = 0.2
def test_vlm_mmmu_benchmark(self):

11
test/registered/ascend/vlm_models/test_ascend_janus_pro_1b.py
View File

@@ -1,13 +1,20 @@
import unittest
from sglang.test.ascend.test_ascend_utils import JANUS_PRO_1B_WEIGHTS_PATH
from sglang.test.ascend.vlm_utils import TestVLMModels
from sglang.test.ci.ci_register import register_npu_ci
register_npu_ci(est_time=400, suite="nightly-4-npu-a3", nightly=True)
class TestGemmaModels(TestVLMModels):
model = "/root/.cache/modelscope/hub/models/deepseek-ai/Janus-Pro-1B"
class TestJanusPro1B(TestVLMModels):
"""Testcase: Verify that the inference accuracy of the deepseek-ai/Janus-Pro-1B model on the MMMU dataset is no less than 0.2.
[Test Category] Model
[Test Target] deepseek-ai/Janus-Pro-1B
"""
model = JANUS_PRO_1B_WEIGHTS_PATH
mmmu_accuracy = 0.2
def test_vlm_mmmu_benchmark(self):

9
test/registered/ascend/vlm_models/test_ascend_janus_pro_7b.py
View File

@@ -1,5 +1,6 @@
import unittest
from sglang.test.ascend.test_ascend_utils import JANUS_PRO_7B_WEIGHTS_PATH
from sglang.test.ascend.vlm_utils import TestVLMModels
from sglang.test.ci.ci_register import register_npu_ci
@@ -7,7 +8,13 @@ register_npu_ci(est_time=400, suite="nightly-4-npu-a3", nightly=True)
class TestJanusPro7B(TestVLMModels):
model = "/root/.cache/modelscope/hub/models/deepseek-ai/Janus-Pro-7B"
"""Testcase: Verify that the inference accuracy of the deepseek-ai/Janus-Pro-7B model on the MMMU dataset is no less than 0.2.
[Test Category] Model
[Test Target] deepseek-ai/Janus-Pro-7B
"""
model = JANUS_PRO_7B_WEIGHTS_PATH
mmmu_accuracy = 0.2
def test_vlm_mmmu_benchmark(self):

7
test/registered/ascend/vlm_models/test_ascend_llama_3_2_11b_vision_instruct.py
View File

@@ -3,7 +3,12 @@ import unittest
from sglang.test.ascend.vlm_utils import TestVLMModels
from sglang.test.ci.ci_register import register_npu_ci
register_npu_ci(est_time=400, suite="nightly-1-npu-a3", nightly=True)
register_npu_ci(
est_time=400,
suite="nightly-1-npu-a3",
nightly=True,
disabled="run failed",
)
class TestLlama3211BVisionInstruct(TestVLMModels):

11
test/registered/ascend/vlm_models/test_ascend_mimo_vl_7b_rl.py
View File

@@ -1,13 +1,20 @@
import unittest
from sglang.test.ascend.test_ascend_utils import MIMO_VL_7B_RL_WEIGHTS_PATH
from sglang.test.ascend.vlm_utils import TestVLMModels
from sglang.test.ci.ci_register import register_npu_ci
register_npu_ci(est_time=400, suite="nightly-4-npu-a3", nightly=True)
class TestGemmaModels(TestVLMModels):
model = "/root/.cache/modelscope/hub/models/XiaomiMiMo/MiMo-VL-7B-RL"
class TestMiMoModels(TestVLMModels):
"""Testcase: Verify that the inference accuracy of the XiaomiMiMo/MiMo-VL-7B-RL model on the MMMU dataset is no less than 0.2.
[Test Category] Model
[Test Target] XiaomiMiMo/MiMo-VL-7B-RL
"""
model = MIMO_VL_7B_RL_WEIGHTS_PATH
mmmu_accuracy = 0.2
def test_vlm_mmmu_benchmark(self):

18
test/registered/ascend/vlm_models/test_ascend_minicpm_o_2_6.py
View File

@@ -1,13 +1,25 @@
import unittest
from sglang.test.ascend.test_ascend_utils import MINICPM_O_2_6_WEIGHTS_PATH
from sglang.test.ascend.vlm_utils import TestVLMModels
from sglang.test.ci.ci_register import register_npu_ci
register_npu_ci(est_time=400, suite="nightly-4-npu-a3", nightly=True)
register_npu_ci(
est_time=400,
suite="nightly-4-npu-a3",
nightly=True,
disabled="run failed",
)
class TestGemmaModels(TestVLMModels):
model = "/root/.cache/modelscope/hub/models/openbmb/MiniCPM-o-2_6"
class TestMiniCPMModelsO(TestVLMModels):
"""Testcase: Verify that the inference accuracy of the openbmb/MiniCPM-o-2_6 model on the MMMU dataset is no less than 0.2.
[Test Category] Model
[Test Target] openbmb/MiniCPM-o-2_6
"""
model = MINICPM_O_2_6_WEIGHTS_PATH
mmmu_accuracy = 0.2
def test_vlm_mmmu_benchmark(self):

11
test/registered/ascend/vlm_models/test_ascend_minicpm_v_2_6.py
View File

@@ -1,13 +1,20 @@
import unittest
from sglang.test.ascend.test_ascend_utils import MINICPM_V_2_6_WEIGHTS_PATH
from sglang.test.ascend.vlm_utils import TestVLMModels
from sglang.test.ci.ci_register import register_npu_ci
register_npu_ci(est_time=400, suite="nightly-4-npu-a3", nightly=True)
class TestGemmaModels(TestVLMModels):
model = "/root/.cache/modelscope/hub/models/openbmb/MiniCPM-V-2_6"
class TestMiniCPMModelsV(TestVLMModels):
"""Testcase: Verify that the inference accuracy of the openbmb/MiniCPM-V-2_6 model on the MMMU dataset is no less than 0.2.
[Test Category] Model
[Test Target] openbmb/MiniCPM-V-2_6
"""
model = MINICPM_V_2_6_WEIGHTS_PATH
mmmu_accuracy = 0.2
def test_vlm_mmmu_benchmark(self):

27
test/registered/ascend/vlm_models/test_ascend_mistral_small_3_1_24b_instruct_2503.py Normal file
View File

@@ -0,0 +1,27 @@
import unittest
from sglang.test.ascend.test_ascend_utils import (
MISTRAL_SMALL_3_1_24B_INSTRUCT_2503_WEIGHTS_PATH,
)
from sglang.test.ascend.vlm_utils import TestVLMModels
from sglang.test.ci.ci_register import register_npu_ci
register_npu_ci(est_time=400, suite="nightly-4-npu-a3", nightly=True)
class TestMistralModels(TestVLMModels):
"""Testcase: Verify that the inference accuracy of the mistralai/Mistral-Small-3.1-24B-Instruct-2503 model on the MMMU dataset is no less than 0.2.
[Test Category] Model
[Test Target] mistralai/Mistral-Small-3.1-24B-Instruct-2503
"""
model = MISTRAL_SMALL_3_1_24B_INSTRUCT_2503_WEIGHTS_PATH
mmmu_accuracy = 0.2
def test_vlm_mmmu_benchmark(self):
self._run_vlm_mmmu_test()
if __name__ == "__main__":
unittest.main()

11
test/registered/ascend/vlm_models/test_ascend_phi4_multimodal_instruct.py
View File

@@ -1,13 +1,20 @@
import unittest
from sglang.test.ascend.test_ascend_utils import PHI_4_MULTIMODAL_INSTRUCT_WEIGHTS_PATH
from sglang.test.ascend.vlm_utils import TestVLMModels
from sglang.test.ci.ci_register import register_npu_ci
register_npu_ci(est_time=400, suite="nightly-4-npu-a3", nightly=True)
class TestGemmaModels(TestVLMModels):
model = "/root/.cache/modelscope/hub/models/microsoft/Phi-4-multimodal-instruct"
class TestPhi4Multimodal(TestVLMModels):
"""Testcase: Verify that the inference accuracy of the microsoft/Phi-4-multimodal-instruct model on the MMMU dataset is no less than 0.2.
[Test Category] Model
[Test Target] microsoft/Phi-4-multimodal-instruct
"""
model = PHI_4_MULTIMODAL_INSTRUCT_WEIGHTS_PATH
mmmu_accuracy = 0.2
def test_vlm_mmmu_benchmark(self):

11
test/registered/ascend/vlm_models/test_ascend_qwen2_5_vl_3b_instruct.py
View File

@@ -1,13 +1,20 @@
import unittest
from sglang.test.ascend.test_ascend_utils import QWEN2_5_VL_3B_INSTRUCT_WEIGHTS_PATH
from sglang.test.ascend.vlm_utils import TestVLMModels
from sglang.test.ci.ci_register import register_npu_ci
register_npu_ci(est_time=400, suite="nightly-4-npu-a3", nightly=True)
class TestGemmaModels(TestVLMModels):
model = "/root/.cache/modelscope/hub/models/Qwen/Qwen2.5-VL-3B-Instruct"
class TestQwen25VL3B(TestVLMModels):
"""Testcase: Verify that the inference accuracy of the Qwen/Qwen2.5-VL-3B-Instruct model on the MMMU dataset is no less than 0.2.
[Test Category] Model
[Test Target] Qwen/Qwen2.5-VL-3B-Instruct
"""
model = QWEN2_5_VL_3B_INSTRUCT_WEIGHTS_PATH
mmmu_accuracy = 0.2
def test_vlm_mmmu_benchmark(self):

40
test/registered/ascend/vlm_models/test_ascend_qwen2_5_vl_72b_instruct.py Normal file
View File

@@ -0,0 +1,40 @@
import unittest
from sglang.test.ascend.test_ascend_utils import QWEN2_5_VL_72B_INSTRUCT_WEIGHTS_PATH
from sglang.test.ascend.vlm_utils import TestVLMModels
from sglang.test.ci.ci_register import register_npu_ci
register_npu_ci(est_time=400, suite="nightly-8-npu-a3", nightly=True)
class TestQwen25VL72B(TestVLMModels):
"""Testcase: Verify that the inference accuracy of the Qwen/Qwen2.5-VL-72B-Instruct model on the MMMU dataset is no less than 0.2.
[Test Category] Model
[Test Target] Qwen/Qwen2.5-VL-72B-Instruct
"""
model = QWEN2_5_VL_72B_INSTRUCT_WEIGHTS_PATH
mmmu_accuracy = 0.2
other_args = [
"--trust-remote-code",
"--cuda-graph-max-bs",
"32",
"--enable-multimodal",
"--mem-fraction-static",
0.6,
"--log-level",
"info",
"--attention-backend",
"ascend",
"--disable-cuda-graph",
"--tp-size",
8,
]
def test_vlm_mmmu_benchmark(self):
self._run_vlm_mmmu_test()
if __name__ == "__main__":
unittest.main()

41
test/registered/ascend/vlm_models/test_ascend_qwen3_vl_235b_a22b_instruct.py Normal file
View File

@@ -0,0 +1,41 @@
import unittest
from sglang.test.ascend.test_ascend_utils import (
QWEN3_VL_235B_A22B_INSTRUCT_WEIGHTS_PATH,
)
from sglang.test.ascend.vlm_utils import TestVLMModels
from sglang.test.ci.ci_register import register_npu_ci
register_npu_ci(est_time=400, suite="nightly-16-npu-a3", nightly=True)
class TestQwen3VL235BA22B(TestVLMModels):
"""Testcase: Verify that the inference accuracy of the Qwen/Qwen3-VL-235B-A22B-Instruct model on the MMMU dataset is no less than 0.2.
[Test Category] Model
[Test Target] Qwen/Qwen3-VL-235B-A22B-Instruct
"""
model = QWEN3_VL_235B_A22B_INSTRUCT_WEIGHTS_PATH
mmmu_accuracy = 0.2
other_args = [
"--trust-remote-code",
"--cuda-graph-max-bs",
"32",
"--enable-multimodal",
"--mem-fraction-static",
0.8,
"--attention-backend",
"ascend",
"--disable-cuda-graph",
"--tp-size",
16,
]
timeout_for_server_launch = 3000
def test_vlm_mmmu_benchmark(self):
self._run_vlm_mmmu_test()
if __name__ == "__main__":
unittest.main()

25
test/registered/ascend/vlm_models/test_ascend_qwen3_vl_30b_a3b_instruct.py Normal file
View File

@@ -0,0 +1,25 @@
import unittest
from sglang.test.ascend.test_ascend_utils import QWEN3_VL_30B_A3B_INSTRUCT_WEIGHTS_PATH
from sglang.test.ascend.vlm_utils import TestVLMModels
from sglang.test.ci.ci_register import register_npu_ci
register_npu_ci(est_time=400, suite="nightly-4-npu-a3", nightly=True)
class TestQwen3VL30BA3B(TestVLMModels):
"""Testcase: Verify that the inference accuracy of the Qwen/Qwen3-VL-30B-A3B-Instruct model on the MMMU dataset is no less than 0.2.
[Test Category] Model
[Test Target] Qwen/Qwen3-VL-30B-A3B-Instruct
"""
model = QWEN3_VL_30B_A3B_INSTRUCT_WEIGHTS_PATH
mmmu_accuracy = 0.2
def test_vlm_mmmu_benchmark(self):
self._run_vlm_mmmu_test()
if __name__ == "__main__":
unittest.main()

25
test/registered/ascend/vlm_models/test_ascend_qwen3_vl_4b_instruct.py Normal file
View File

@@ -0,0 +1,25 @@
import unittest
from sglang.test.ascend.test_ascend_utils import QWEN3_VL_4B_INSTRUCT_WEIGHTS_PATH
from sglang.test.ascend.vlm_utils import TestVLMModels
from sglang.test.ci.ci_register import register_npu_ci
register_npu_ci(est_time=400, suite="nightly-4-npu-a3", nightly=True)
class TestQwen3VL4B(TestVLMModels):
"""Testcase: Verify that the inference accuracy of the Qwen/Qwen3-VL-4B-Instruct model on the MMMU dataset is no less than 0.2.
[Test Category] Model
[Test Target] Qwen/Qwen3-VL-4B-Instruct
"""
model = QWEN3_VL_4B_INSTRUCT_WEIGHTS_PATH
mmmu_accuracy = 0.2
def test_vlm_mmmu_benchmark(self):
self._run_vlm_mmmu_test()
if __name__ == "__main__":
unittest.main()

25
test/registered/ascend/vlm_models/test_ascend_qwen3_vl_8b_instruct.py Normal file
View File

@@ -0,0 +1,25 @@
import unittest
from sglang.test.ascend.test_ascend_utils import QWEN3_VL_8B_INSTRUCT_WEIGHTS_PATH
from sglang.test.ascend.vlm_utils import TestVLMModels
from sglang.test.ci.ci_register import register_npu_ci
register_npu_ci(est_time=400, suite="nightly-4-npu-a3", nightly=True)
class TestQwen3VL8B(TestVLMModels):
"""Testcase: Verify that the inference accuracy of the Qwen/Qwen3-VL-8B-Instruct model on the MMMU dataset is no less than 0.2.
[Test Category] Model
[Test Target] Qwen/Qwen3-VL-8B-Instruct
"""
model = QWEN3_VL_8B_INSTRUCT_WEIGHTS_PATH
mmmu_accuracy = 0.2
def test_vlm_mmmu_benchmark(self):
self._run_vlm_mmmu_test()
if __name__ == "__main__":
unittest.main()

9
test/run_suite.py
View File

@@ -41,7 +41,13 @@ PER_COMMIT_SUITES = {
"stage-c-test-8-gpu-b200",
"stage-c-test-deepep-8-gpu-h200",
],
HWBackend.NPU: [],
HWBackend.NPU: [
"stage-a-test-1",
"stage-b-test-1-npu-a2",
"stage-b-test-2-npu-a2",
"stage-b-test-4-npu-a3",
"stage-b-test-16-npu-a3",
],
}
# Nightly test suites (run nightly, organized by GPU configuration)
@@ -76,6 +82,7 @@ NIGHTLY_SUITES = {
"nightly-1-npu-a3",
"nightly-2-npu-a3",
"nightly-4-npu-a3",
"nightly-8-npu-a3",
"nightly-16-npu-a3",
],
}