GLM-5.1

GLM-5.1

GLM-5.1은 GLM-5을 잇는 Zhipu AI의 최신 플래그십 언어 모델 시리즈로, 복잡한 시스템 엔지니어링과 장기 지평 에이전트 작업을 겨냥해요. DeepSeek Sparse Attention (DSA) 구조를 기반으로 장문 컨텍스트 용량을 유지하면서 배포 비용을 크게 줄였어요.

BF16(풀 프리시전), FP8(8-bit 양자화), NVFP4(4-bit 양자화, NVIDIA), MXFP4(AMD MI355X용) 변형을 제공하며 NVIDIA H100/H200/B300/GB300과 AMD MI300X/MI325X/MI355X GPU를 모두 지원해요. MIT 라이선스로 공개되었어요.

이 문서는 SGLang으로 GLM-5.1을 배포하고, 추론 파서·함수 호출 같은 고급 기능과 벤치마크를 실행하는 방법을 설명해요. 정확도 벤치마크 결과는 공식적으로 GLM-5와 공유되며, 별도 GLM-5.1 실행이 계획되어 있어요.

원문 페이지에는 하드웨어 플랫폼, 양자화 방법, 배포 전략 등을 골라 실행할 배포 명령어를 자동으로 만들어 주는 대화형 선택기가 포함되어 있어요. 위키에서는 렌더링되지 않으니, 아래 섹션의 명령어를 직접 참고하면 돼요.

출처: 문서

본문

1. 모델 소개

제공 모델:

• BF16 (풀 프리시전): zai-org/GLM-5.1
• FP8 (8-bit 양자화): zai-org/GLM-5.1-FP8
• NVFP4 (4-bit 양자화): nvidia/GLM-5.1-NVFP4

라이선스: MIT

2. SGLang 설치

설치 안내는 공식 SGLang 설치 가이드를 참고하세요.

3. 모델 배포

이 섹션에서는 하드웨어 플랫폼과 사용 사례에 맞게 최적화된 배포 구성을 제공해요.

3.1 기본 구성

대화형 명령 생성기: 아래 구성 선택기를 사용하면 하드웨어 플랫폼·양자화 방법·기능에 맞는 배포 명령을 자동으로 생성할 수 있어요. SGLang은 NVIDIA H100, H200, B300, GB300 및 AMD MI300X/MI325X/MI355X GPU에서 GLM-5.1 서빙을 지원해요.

여기 있는 모든 레시피는 기본 `--dsa-topk-backend sgl-kernel`에서 DSA 인덱서 top-k를 실행해요. 다른 top-k 백엔드 선택은 GLM-5.1에서 완전히 검증되지 않았어요.

3.2 구성 팁

• 추측 디코딩(MTP)은 대화형 사용 사례의 지연 시간을 크게 줄일 수 있어요.
• DP Attention: 높은 동시성에서 더 높은 처리량을 위한 데이터 병렬 어텐션을 활성화해요. 단, DP attention은 낮은 동시성 지연 시간을 높은 동시성 처리량과 맞바꾸는 점을 유의하세요 — 동시 요청이 적고 지연 시간에 민감한 워크로드라면 비활성화해야 해요.
• --mem-fraction-static 플래그는 최적의 메모리 활용을 위해 권장되며, 하드웨어와 워크로드에 맞게 조정하세요.

하드웨어	NVFP4	FP8	BF16	MXFP4
H100	—	tp=16	—	—
H200	—	tp=8	—	—
B300	tp=8	—	—	—
GB300	tp=4	—	—	—
MI300X/MI325X	—	tp=8	tp=8	—
MI355X	—	tp=8	tp=8	tp=4

• H100과 H200: FP8이 권장 배포 경로예요.

• B300과 GB300: NVFP4가 권장 배포 경로예요. nvidia/GLM-5.1-NVFP4를 --quantization modelopt_fp4와 함께 사용하세요. B300에서는 tp=8, GB300에서는 tp=4를 사용하세요. B300과 GB300에는 CUDA 13 이미지 변형이 필요해요.

• AMD GPU: BF16과 FP8 체크포인트는 MI300X/MI325X/MI355X에서 tp=8로 실행돼요. MI355X(gfx950)에서는 MXFP4 체크포인트 amd/GLM-5.1-MXFP4도 --kv-cache-dtype fp8_e4m3와 함께 tp=4로 지원돼요. 모든 AMD 경로는 --dsa-prefill-backend tilelang --dsa-decode-backend tilelang, --chunked-prefill-size 131072, --watchdog-timeout 1200(가중치 로딩 20분)을 전달해요. FP8은 BF16 대비 약 절반의 메모리를 사용해요(~89GB/GPU vs ~175GB/GPU). EAGLE 추측 디코딩은 AMD GPU(MI300X/MI325X(gfx942)과 MI355X(gfx950))에서 지원되지만 --disable-custom-all-reduce가 필요해요 — aiter 커스텀 all-reduce 커널이 높은 동시성에서 EAGLE 검증 중 데드락을 일으키므로, 이 플래그 없이는 서버가 멈출 수 있어요.

• 다른 구성 팁(MTP, DSA 커널, Context Parallel, HiSparse, NVFP4, Index Cache)은 DeepSeek-V3.2 cookbook 페이지를 참고하세요. GLM-5.1과 DeepSeek-V3.2는 같은 모델 구조를 공유하므로 최적화 기법도 공통이에요.

• CUDA의 Prefill CP: Zigzag(--cp-strategy zigzag)는 GLM-5.1에서 임시로 사용할 수 없어요. --dp 1과 함께 --enable-prefill-cp --cp-strategy interleave를 사용하세요.

• IndexCache 메서드를 활성화하려면 GLM-5.1에 --json-model-override-args '{"index_topk_pattern": "FFSFSSSFSSFFFSSSFFFSFSSSSSSFFSFFSFFSSFFFFFFSFFFFFSFFSSSSSSFSFFFSFSSSFSFFSFFSSS"}'를 사용하세요. 이 방식은 작은 정확도 손실만으로 서빙 효율을 개선할 수 있어요. 엄격한 정확도 평가를 실행한다면 이 기능을 활성화하지 마세요.

4. 모델 호출

다음 명령으로 GLM-5.1을 배포해요 (H200에서 FP8, 모든 기능 활성화):

sglang serve \
  --model-path zai-org/GLM-5.1-FP8 \
  --tp 8 \
  --tool-call-parser glm47 \
  --reasoning-parser glm45 \
  --speculative-algorithm EAGLE \
  --speculative-num-steps 3 \
  --speculative-eagle-topk 1 \
  --speculative-num-draft-tokens 4 \
  --mem-fraction-static 0.85 \
  --host 0.0.0.0 \
  --port 30000

4.1 B300/GB300 (NVFP4) 서버 명령

B300

sglang serve \
  --model-path nvidia/GLM-5.1-NVFP4 \
  --tp 8 \
  --quantization modelopt_fp4 \
  --tool-call-parser glm47 \
  --reasoning-parser glm45 \
  --speculative-algorithm EAGLE \
  --speculative-num-steps 3 \
  --speculative-eagle-topk 1 \
  --speculative-num-draft-tokens 4 \
  --trust-remote-code \
  --mem-fraction-static 0.80 \
  --host 0.0.0.0 \
  --port 30000

GB300

sglang serve \
  --model-path nvidia/GLM-5.1-NVFP4 \
  --tp 4 \
  --quantization modelopt_fp4 \
  --tool-call-parser glm47 \
  --reasoning-parser glm45 \
  --speculative-algorithm EAGLE \
  --speculative-num-steps 3 \
  --speculative-eagle-topk 1 \
  --speculative-num-draft-tokens 4 \
  --trust-remote-code \
  --mem-fraction-static 0.80 \
  --host 0.0.0.0 \
  --port 30000

4.2 MI300X/MI325X/MI355X (ROCm) 서버 명령

다음 ROCm 명령은 AMD GPU를 위한 추가 옵션이며 위 NVIDIA 지침을 대체하지 않아요.

MXFP4 (MI355X / gfx950)

MI355X(gfx950)에서는 SGLANG_DSA_TRITON_PREFILL=1을 설정해 prefill 단계에 더 빠른 Triton 어텐션 커널을 활성화할 수 있어요(선택 사항, 기본 꺼짐). 보이는 것처럼 --dsa-prefill-backend tilelang을 유지하세요. 아래 EAGLE 추측 디코딩 플래그는 선택 사항이지만 gfx950에서는 권장돼요.

# SGLANG_DSA_TRITON_PREFILL=1 is optional; it enables a faster Triton prefill kernel on gfx950
SGLANG_DSA_TRITON_PREFILL=1 sglang serve \
  --model-path amd/GLM-5.1-MXFP4 \
  --tp 4 \
  --trust-remote-code \
  --kv-cache-dtype fp8_e4m3 \
  --tool-call-parser glm47 \
  --reasoning-parser glm45 \
  --dsa-prefill-backend tilelang \
  --dsa-decode-backend tilelang \
  --chunked-prefill-size 131072 \
  --mem-fraction-static 0.85 \
  --watchdog-timeout 1200 \
  --speculative-algorithm EAGLE \
  --speculative-num-steps 3 \
  --speculative-eagle-topk 1 \
  --speculative-num-draft-tokens 4 \
  --disable-custom-all-reduce \
  --host 0.0.0.0 \
  --port 30000

FP8 (권장)

sglang serve \
  --model-path zai-org/GLM-5.1-FP8 \
  --tp 8 \
  --trust-remote-code \
  --tool-call-parser glm47 \
  --reasoning-parser glm45 \
  --dsa-prefill-backend tilelang \
  --dsa-decode-backend tilelang \
  --chunked-prefill-size 131072 \
  --mem-fraction-static 0.80 \
  --watchdog-timeout 1200 \
  --speculative-algorithm EAGLE \
  --speculative-num-steps 3 \
  --speculative-eagle-topk 1 \
  --speculative-num-draft-tokens 4 \
  --disable-custom-all-reduce \
  --host 0.0.0.0 \
  --port 30000

BF16

sglang serve \
  --model-path zai-org/GLM-5.1 \
  --tp 8 \
  --trust-remote-code \
  --dsa-prefill-backend tilelang \
  --dsa-decode-backend tilelang \
  --chunked-prefill-size 131072 \
  --mem-fraction-static 0.80 \
  --watchdog-timeout 1200 \
  --speculative-algorithm EAGLE \
  --speculative-num-steps 3 \
  --speculative-eagle-topk 1 \
  --speculative-num-draft-tokens 4 \
  --disable-custom-all-reduce \
  --host 0.0.0.0 \
  --port 30000

4.3 기본 사용법

기본 API 사용법과 요청 예시는 아래를 참고하세요:

• SGLang 기본 사용 가이드

4.4 고급 사용법

4.4.1 추론(Reasoning) 파서

GLM-5.1은 기본적으로 Thinking 모드를 지원해요. 배포 시 추론 파서를 활성화하면 thinking 영역과 content 영역을 분리할 수 있어요. thinking 과정은 스트리밍 응답의 reasoning_content를 통해 반환돼요.

thinking을 비활성화하고 Instruct 모드를 사용하려면 요청 시 chat_template_kwargs를 전달하세요:

• Thinking 모드 (기본값): 모델이 답변 전에 단계별 추론을 수행해요. 추가 파라미터가 필요 없어요.
• Instruct 모드 ({"enable_thinking": false}): 모델이 thinking 과정 없이 직접 응답해요.

예시 1: Thinking 모드 (기본값)

Thinking 모드는 기본적으로 활성화되어 있어요. 모델은 답변 전에 단계별로 추론하며, thinking 과정은 reasoning_content로 반환돼요:

from openai import OpenAI

client = OpenAI(
    base_url="http://localhost:30000/v1",
    api_key="EMPTY"
)

# Thinking mode is enabled by default, no extra parameters needed
response = client.chat.completions.create(
    model="zai-org/GLM-5.1-FP8",
    messages=[
        {"role": "user", "content": "Solve this problem step by step: What is 15% of 240?"}
    ],
    max_tokens=2048,
    stream=True
)

# Process the stream
has_thinking = False
has_answer = False
thinking_started = False

for chunk in response:
    if chunk.choices and len(chunk.choices) > 0:
        delta = chunk.choices[0].delta

        # Print thinking process
        if hasattr(delta, 'reasoning_content') and delta.reasoning_content:
            if not thinking_started:
                print("=============== Thinking =================", flush=True)
                thinking_started = True
            has_thinking = True
            print(delta.reasoning_content, end="", flush=True)

        # Print answer content
        if delta.content:
            # Close thinking section and add content header
            if has_thinking and not has_answer:
                print("\n=============== Content =================", flush=True)
                has_answer = True
            print(delta.content, end="", flush=True)

print()

출력 예시:

=============== Thinking =================
1.  **Understand the Goal:** The user wants to find 15% of 240, and they want the solution explained step-by-step.

2.  **Identify the Core Mathematical Concept:** "Percent" means "per hundred" or "out of 100". Finding "X% of Y" translates to the mathematical operation: $(X / 100) \times Y$.

3.  **Step-by-Step Breakdown:**
    *   *Step 1: Convert the percentage to a decimal (or fraction).* 15% means 15 out of 100, which is $15/100$ or $0.15$.
    *   *Step 2: Multiply the decimal by the given number.* Multiply $0.15$ by $240$.
    *   *Step 3: Perform the calculation.*
        *   $0.15 \times 240$
        *   I can break this down further to make it easy to follow:
            *   $0.10 \times 240 = 24$ (which is 10%)
            *   $0.05 \times 240 = 12$ (which is 5%, half of 10%)
            *   $24 + 12 = 36$
        *   Alternatively, standard multiplication:
            *   $240 \times 15 = 3600$
            *   Move decimal two places left -> $36$
    *   *Step 4: State the final answer clearly.*

4.  **Draft the Response (incorporating the steps clearly):**
    *   *Introduction:* State the problem clearly.
    *   *Step 1:* Explain how to convert 15% to a decimal.
    *   *Step 2:* Explain the multiplication step.
    *   *Step 3:* Show the actual math (I'll provide the standard multiplication and the "mental math" trick as it adds value).
    *   *Conclusion:* Give the final answer.

5.  **Refine the Output (Self-Correction/Polishing during drafting):**
    *   *Drafting Step 1:* To find 15% of 240, first convert 15% into a decimal. Since percent means "per hundred," you divide 15 by 100. 15 ÷ 100 = 0.15.
    *   *Drafting Step 2:* Next, multiply this decimal by the number you are finding the percentage of (which is 240). So, calculate 0.15 × 240.
    *   *Drafting Step 3 (Standard way):* 0.15 × 240 = 36.
    *   *Adding the alternative mental math way:* It's often helpful to break it down into 10% and 5%.
        *   10% of 240 = 24 (move the decimal point one place to the left)
        *   5% is half of 10%, so half of 24 = 12
        *   Add them together: 24 + 12 = 36.
    *   *Final Answer:* 15% of 240 is 36.

6.  **Final Review against User Prompt:** Does it solve the problem? Yes. Is it step-by-step? Yes. Is it clear? Yes. (Proceed to generate output).
=============== Content =================
Here is the step-by-step solution to find 15% of 240:

**Step 1: Convert the percentage to a decimal.**
To convert a percentage to a decimal, divide it by 100 (or simply move the decimal point two places to the left).
* 15% = 15 ÷ 100 = **0.15**

**Step 2: Multiply the decimal by the number.**
Now, multiply the decimal (0.15) by the number you are finding the percentage of (240).
* 0.15 × 240 = **36**

*(Alternative mental math method for Step 2)*:
If you don't want to multiply by 0.15 directly, you can break 15% down into 10% and 5%:
* **10% of 240** = 24 (just move the decimal point one place to the left)
* **5% of 240** = 12 (5% is half of 10%, so just divide 24 by 2)
* **Add them together**: 24 + 12 = **36**

**Answer:**
15% of 240 is **36**.

예시 2: Instruct 모드 (Thinking 끄기)

thinking을 비활성화하고 직접 응답을 받으려면 chat_template_kwargs로 {"enable_thinking": false}를 전달하세요:

from openai import OpenAI

client = OpenAI(
    base_url="http://localhost:30000/v1",
    api_key="EMPTY"
)

# Disable thinking mode via chat_template_kwargs
response = client.chat.completions.create(
    model="zai-org/GLM-5.1-FP8",
    messages=[
        {"role": "user", "content": "What is 15% of 240?"}
    ],
    extra_body={"chat_template_kwargs": {"enable_thinking": False}},
    max_tokens=2048,
    stream=True
)

# In Instruct mode, the model responds directly without reasoning_content
for chunk in response:
    if chunk.choices and len(chunk.choices) > 0:
        delta = chunk.choices[0].delta
        if delta.content:
            print(delta.content, end="", flush=True)

print()

출력 예시:

15% of 240 is 36.

Here is how to calculate it:
1. Convert the percentage to a decimal: 15% = 0.15
2. Multiply the decimal by the number: 0.15 × 240 = 36

4.4.2 함수 호출(Tool Calling)

GLM-5.1은 함수 호출 기능을 지원해요. 배포 시 함수 호출 파서를 활성화하세요. Thinking 모드는 기본적으로 켜져 있으며, 함수 호출 요청에서 비활성화하려면 extra_body={"chat_template_kwargs": {"enable_thinking": False}}를 전달하세요.

Python 예시 (Thinking 과정 포함):

from openai import OpenAI

client = OpenAI(
    base_url="http://localhost:30000/v1",
    api_key="EMPTY"
)

# Define available tools
tools = [
    {
        "type": "function",
        "function": {
            "name": "get_weather",
            "description": "Get the current weather for a location",
            "parameters": {
                "type": "object",
                "properties": {
                    "location": {
                        "type": "string",
                        "description": "The city name"
                    },
                    "unit": {
                        "type": "string",
                        "enum": ["celsius", "fahrenheit"],
                        "description": "Temperature unit"
                    }
                },
                "required": ["location"]
            }
        }
    }
]

# Make request with streaming to see thinking process
response = client.chat.completions.create(
    model="zai-org/GLM-5.1-FP8",
    messages=[
        {"role": "user", "content": "What's the weather in Beijing?"}
    ],
    tools=tools,
    stream=True
)

# Process streaming response
thinking_started = False
has_thinking = False

for chunk in response:
    if chunk.choices and len(chunk.choices) > 0:
        delta = chunk.choices[0].delta

        # Print thinking process
        if hasattr(delta, 'reasoning_content') and delta.reasoning_content:
            if not thinking_started:
                print("=============== Thinking =================", flush=True)
                thinking_started = True
            has_thinking = True
            print(delta.reasoning_content, end="", flush=True)

        # Print tool calls
        if hasattr(delta, 'tool_calls') and delta.tool_calls:
            # Close thinking section if needed
            if has_thinking and thinking_started:
                print("\n=============== Content =================", flush=True)
                thinking_started = False

            for tool_call in delta.tool_calls:
                if tool_call.function:
                    print(f"Tool Call: {tool_call.function.name}")
                    print(f"   Arguments: {tool_call.function.arguments}")

        # Print content
        if delta.content:
            print(delta.content, end="", flush=True)

print()

출력 예시:

=============== Thinking =================
The user wants to know the weather in Beijing. I'll call the get_weather function with "Beijing" as the location.
=============== Content =================
Tool Call: get_weather
   Arguments:
Tool Call: None
   Arguments: {
Tool Call: None
   Arguments: "location": "Be
Tool Call: None
   Arguments: ijing"
Tool Call: None
   Arguments: }

5. 벤치마크

5.1 속도 벤치마크

테스트 환경:

• 하드웨어: H200 (8x)
• 모델: GLM-5.1-FP8
• 텐서 병렬화: 8
• SGLang 버전: commit 947927bdb

5.1.1 지연 시간 벤치마크

python3 -m sglang.bench_serving \
  --backend sglang \
  --model zai-org/GLM-5.1-FP8 \
  --dataset-name random \
  --random-input-len 1000 \
  --random-output-len 1000 \
  --num-prompts 10 \
  --max-concurrency 1 \
  --request-rate inf

============ Serving Benchmark Result ============
Backend:                                 sglang
Traffic request rate:                    inf
Max request concurrency:                 1
Successful requests:                     10
Benchmark duration (s):                  35.78
Total input tokens:                      6101
Total input text tokens:                 6101
Total generated tokens:                  4220
Total generated tokens (retokenized):    4213
Request throughput (req/s):              0.28
Input token throughput (tok/s):          170.54
Output token throughput (tok/s):         117.96
Peak output token throughput (tok/s):    148.00
Peak concurrent requests:                2
Total token throughput (tok/s):          288.50
Concurrency:                             1.00
Accept length:                           3.48
----------------End-to-End Latency----------------
Mean E2E Latency (ms):                   3576.31
Median E2E Latency (ms):                 2935.97
P90 E2E Latency (ms):                    5908.97
P99 E2E Latency (ms):                    8588.08
---------------Time to First Token----------------
Mean TTFT (ms):                          290.88
Median TTFT (ms):                        282.34
P99 TTFT (ms):                           332.27
-----Time per Output Token (excl. 1st token)------
Mean TPOT (ms):                          7.54
Median TPOT (ms):                        6.97
P99 TPOT (ms):                           9.04
---------------Inter-Token Latency----------------
Mean ITL (ms):                           7.80
Median ITL (ms):                         6.81
P95 ITL (ms):                            13.51
P99 ITL (ms):                            26.99
Max ITL (ms):                            29.50
==================================================

5.1.2 처리량 벤치마크

python3 -m sglang.bench_serving \
  --backend sglang \
  --model zai-org/GLM-5.1-FP8 \
  --dataset-name random \
  --random-input-len 1000 \
  --random-output-len 1000 \
  --num-prompts 1000 \
  --max-concurrency 100 \
  --request-rate inf

============ Serving Benchmark Result ============
Backend:                                 sglang
Traffic request rate:                    inf
Max request concurrency:                 100
Successful requests:                     1000
Benchmark duration (s):                  411.74
Total input tokens:                      502493
Total input text tokens:                 502493
Total generated tokens:                  500251
Total generated tokens (retokenized):    499614
Request throughput (req/s):              2.43
Input token throughput (tok/s):          1220.41
Output token throughput (tok/s):         1214.97
Peak output token throughput (tok/s):    2648.00
Peak concurrent requests:                105
Total token throughput (tok/s):          2435.38
Concurrency:                             96.30
Accept length:                           3.50
----------------End-to-End Latency----------------
Mean E2E Latency (ms):                   39648.76
Median E2E Latency (ms):                 39058.12
P90 E2E Latency (ms):                    57009.82
P99 E2E Latency (ms):                    68880.33
---------------Time to First Token----------------
Mean TTFT (ms):                          20613.80
Median TTFT (ms):                        21429.21
P99 TTFT (ms):                           29543.17
-----Time per Output Token (excl. 1st token)------
Mean TPOT (ms):                          38.73
Median TPOT (ms):                        36.52
P99 TPOT (ms):                           67.09
---------------Inter-Token Latency----------------
Mean ITL (ms):                           38.13
Median ITL (ms):                         16.57
P95 ITL (ms):                            86.01
P99 ITL (ms):                            164.88
Max ITL (ms):                            1307.02
==================================================

5.2 정확도 벤치마크

아래 정확도 벤치마크 결과는 GLM-5와 공유돼요. 글을 쓰는 시점에 GLM-5.1이 별도로 벤치마크되지 않았기 때문이에요. 별도의 벤치마크 실행이 계획되어 있어요.

5.2.1 GSM8K 벤치마크

• 벤치마크 명령

python3 benchmark/gsm8k/bench_sglang.py --port 30000

• 테스트 결과

Accuracy: 0.955
Invalid: 0.000
Latency: 32.470 s
Output throughput: 642.044 token/s

5.2.2 MMLU 벤치마크

• 벤치마크 명령

python3 benchmark/mmlu/bench_sglang.py --port 30000

• 테스트 결과

subject: abstract_algebra, #q:100, acc: 0.860
subject: anatomy, #q:135, acc: 0.874
subject: astronomy, #q:152, acc: 0.941
subject: business_ethics, #q:100, acc: 0.880
subject: clinical_knowledge, #q:265, acc: 0.932
subject: college_biology, #q:144, acc: 0.972
subject: college_chemistry, #q:100, acc: 0.640
subject: college_computer_science, #q:100, acc: 0.900
subject: college_mathematics, #q:100, acc: 0.810
subject: college_medicine, #q:173, acc: 0.873
subject: college_physics, #q:102, acc: 0.912
subject: computer_security, #q:100, acc: 0.880
subject: conceptual_physics, #q:235, acc: 0.928
subject: econometrics, #q:114, acc: 0.807
subject: electrical_engineering, #q:145, acc: 0.897
subject: elementary_mathematics, #q:378, acc: 0.937
subject: formal_logic, #q:126, acc: 0.778
subject: global_facts, #q:100, acc: 0.710
subject: high_school_biology, #q:310, acc: 0.961
subject: high_school_chemistry, #q:203, acc: 0.847
subject: high_school_computer_science, #q:100, acc: 0.960
subject: high_school_european_history, #q:165, acc: 0.891
subject: high_school_geography, #q:198, acc: 0.960
subject: high_school_government_and_politics, #q:193, acc: 0.984
subject: high_school_macroeconomics, #q:390, acc: 0.923
subject: high_school_mathematics, #q:270, acc: 0.696
subject: high_school_microeconomics, #q:238, acc: 0.962
subject: high_school_physics, #q:151, acc: 0.821
subject: high_school_psychology, #q:545, acc: 0.956
subject: high_school_statistics, #q:216, acc: 0.889
subject: high_school_us_history, #q:204, acc: 0.941
subject: high_school_world_history, #q:237, acc: 0.945
subject: human_aging, #q:223, acc: 0.857
subject: human_sexuality, #q:131, acc: 0.908
subject: international_law, #q:121, acc: 0.934
subject: jurisprudence, #q:108, acc: 0.907
subject: logical_fallacies, #q:163, acc: 0.933
subject: machine_learning, #q:112, acc: 0.830
subject: management, #q:103, acc: 0.942
subject: marketing, #q:234, acc: 0.940
subject: medical_genetics, #q:100, acc: 0.990
subject: miscellaneous, #q:783, acc: 0.959
subject: moral_disputes, #q:346, acc: 0.873
subject: moral_scenarios, #q:895, acc: 0.837
subject: nutrition, #q:306, acc: 0.922
subject: philosophy, #q:311, acc: 0.897
subject: prehistory, #q:324, acc: 0.929
subject: professional_accounting, #q:282, acc: 0.844
subject: professional_law, #q:1534, acc: 0.714
subject: professional_medicine, #q:272, acc: 0.941
subject: professional_psychology, #q:612, acc: 0.913
subject: public_relations, #q:110, acc: 0.791
subject: security_studies, #q:245, acc: 0.878
subject: sociology, #q:201, acc: 0.940
subject: us_foreign_policy, #q:100, acc: 0.920
subject: virology, #q:166, acc: 0.596
subject: world_religions, #q:171, acc: 0.936
Total latency: 165.275
Average accuracy: 0.877

5.3 AMD GPU 벤치마크

5.3.1 GSM8K 벤치마크 (MI325/MI35x)

• MI325/MI35x 테스트 (GLM-5.1 BF16, tp=8, TileLang DSA 백엔드)

python3 benchmark/gsm8k/bench_sglang.py --num-questions 200

Accuracy: 0.970
Invalid: 0.000

결과는 AMD nightly CI에서 가져온 거예요. sglang#18911도 참고하세요.

더 알아보기 (Learn more)

• GLM-5.1 모델 카드
• GLM-5 cookbook 페이지
• DeepSeek-V3.2 cookbook 페이지
• SGLang 설치 가이드