MiMo-V2.5

3.2 구성 팁

MiMo-V2.5-Pro (1.02T):

• B200: 단일 노드, TP=8 (검증됨). --attention-backend fa4 + --moe-runner-backend flashinfer_trtllm + --mem-fraction-static 0.8 사용. KV-cache 풋프린트를 192 GB HBM 내에 유지하려면 --swa-full-tokens-ratio 0.1 설정.
• GB300: 2 노드, TP=8 (검증됨). B200과 같은 Blackwell 스택; 멀티노드 인터커넥트는 NCCL_MNNVL_ENABLE=1 NCCL_CUMEM_ENABLE=1 필요. 기본 SWA 비율로 충분.
• H100/H200: 2 노드 × 8 GPU (TP=16, 아직 검증 안 됨). Hopper 스택(fa3 + DeepEP + EAGLE multi-layer) 사용; --mem-fraction-static 0.7과 --swa-full-tokens-ratio 0.3으로 맞음. DeepEP 디스패치 튜닝: SGLANG_DEEPEP_NUM_MAX_DISPATCH_TOKENS_PER_RANK=256은 prefill 중 메모리 급증을 피해줘요.
• EAGLE 추측 디코딩(3 steps, topk=1)은 보통 2–3× 디코드 속도 향상을 제공해요. --enable-multi-layer-eagle 필요(Hopper와 Blackwell 모두). 자연어 vs 랜덤 프롬프트의 수락률 동작은 §5.4 참고.

MiMo-V2.5 (310B):

• 체크포인트는 TP=4-interleaved fused qkv_proj를 갖고 있어요. DP 그룹당 어텐션-TP 반드시 4여야 해요. --dp = TP / 4 사용; TP > 4에서는 DP-attention도 필요해요. 총 GPU 수는 4의 배수여야 해요. --dp 2 없이 그냥 --tp 8을 쓰면 MiMoV2 fused qkv_proj checkpoint is TP=4-interleaved; got attention tp_size=8으로 로딩이 실패해요.
• 단일 노드 배포: H100/H200 8× GPU (--tp 8 --dp 2), B200 4× GPU (--tp 4, dp=1, DP-attn 플래그 불필요), GB300 4× GPU (--tp 4, 단일 NVL4 노드). FP8 양자화.
• Blackwell에서 --attention-backend fa4를 전달하세요. MiMoV2의 비대칭 KV(head_dim 192 / v_head_dim 128)는 K/V 폭이 같아야 하는 SM100 기본 trtllm_mha에서 실패해요.
• Blackwell에서 V2.5 비전 인코더를 위해 --mm-attention-backend fa4를 전달하세요. 체크포인트 구성은 내부적으로 FlashAttention-3을 요청하지만 SGLang은 Blackwell에서 FA3을 거부하고 멀티모달 어텐션에 FA4를 기대해요.
• Blackwell에서 --moe-runner-backend flashinfer_trtllm을 전달하세요. 기본 auto는 triton fused-MoE 러너로 폴백되어 bs=1 디코드에서 ~12% 더 느려요.
• --enable-dp-attention이 켜질 때마다 LM 헤드와 인코더 샤딩을 일관되게 유지하려면 --enable-dp-lm-head와 --mm-enable-dp-encoder가 필요해요.
• EAGLE MTP는 체크포인트의 MTP 가중치를 사용해요. --speculative-algorithm EAGLE와 --enable-multi-layer-eagle(Hopper와 Blackwell 모두)로 활성화.
• 멀티모달: 이미지, 비디오, 오디오 이해를 지원. 호출 예제는 섹션 4.3 참고.

DeepEP (선택 토글, Hopper 전용):

• DeepEP는 기본 MoE all-to-all 디스패치를 fused DeepEP 백엔드로 교체해요. 전문가 디스패치 지연 시간과 메모리 트래픽을 낮춰 H100/H200에서 고동시성 / 처리량 중심 워크로드에 효과적이에요. concurrency=1 / 지연 시간 중심 워크로드에서는 이득이 무시할 만하므로 꺼 두세요.
• 활성화하면 --moe-a2a-backend deepep + --moe-dense-tp-size 1(Pro는 --ep <tp> 추가)과 디스패치 버퍼를 제한하는 SGLANG_DEEPEP_NUM_MAX_DISPATCH_TOKENS_PER_RANK=256 환경 변수가 추가돼요. pip install deep_ep 필요(기본 sglang 설치에 포함 안 됨).
• Blackwell(B200, GB300)에서는 검증된 MoE 백엔드가 flashinfer_trtllm이고, DeepEP 토글은 거기서 무의미해요.

3.3 TPU 배포 (MiMo-V2.5-Pro, sgl-jax)

MiMo-V2.5-Pro는 sgl-jax로 TPU에서도 서빙할 수 있어요. 런타임은 별도의 JAX 기반 스택(sgl_jax.launch_server)이에요. 위 패널에서 TPU v7x 또는 TPU v6e를 선택해 실행 명령을 생성하세요. 검증된 토폴로지:

v7x는 칩당 2개의 논리 JAX 장치를 노출하므로 --tp-size = 16 chips × 2 = 32예요. v6e는 칩당 1개 장치를 노출하므로 --tp-size = 64예요. 항상 --tp-size를 칩 수가 아닌 모든 노드의 총 JAX 장치 수로 설정하세요.

모든 노드는 같은 TPU 슬라이스에 있어야 하고 JAX 초기화 포트(20000)와 TPU 프로세스 포트(8471)에서 서로 도달할 수 있어야 해요.

1단계 — 모든 노드에서 JAX TPU 컨테이너 시작:

docker run -it --privileged \
  --shm-size=32g \
  --ipc=host \
  --network=host \
  -v /dev:/dev \
  us-docker.pkg.dev/cloud-tpu-images/jax-ai-image/tpu:jax0.8.1-rev1 bash

이미지는 JAX 런타임을 sgl-jax의 TPU 엑스트라와 정렬하기 위해 jax0.8.1-rev1에 고정돼요.

2단계 — sgl-jax 복제·설치 (컨테이너 안):

git clone https://github.com/sgl-project/sglang-jax.git
cd sglang-jax
pip install -e "python[tpu]"

4. 모델 호출

4.1 기본 사용

Basic API Usage 참조.

4.2 추론 출력

두 변형 모두 하이브리드 thinking 모드를 지원해요. thinking 내용은 reasoning parser로 분리돼요.

Thinking Mode (기본값):

from openai import OpenAI

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

response = client.chat.completions.create(
    model="XiaomiMiMo/MiMo-V2.5",
    messages=[
        {"role": "user", "content": "Which is larger, 9.11 or 9.9? Think carefully."}
    ]
)

print("====== Reasoning ======")
print(response.choices[0].message.reasoning_content)
print("====== Answer ======")
print(response.choices[0].message.content)

출력 예제 (MiMo-V2.5):

====== Reasoning ======
Comparing 9.11 and 9.9.

The integer parts are both 9. Now compare the decimal parts: 0.11 vs 0.9.

0.9 = 0.90, which is greater than 0.11.

So 9.9 > 9.11.
====== Answer ======
**9.9 is larger than 9.11.**

Here's the reasoning: When comparing decimals, line them up to the same number of decimal places:

- 9.11
- 9.90

Both have a **9** in the ones place, but in the tenths place, **9 > 1**, so 9.90 > 0.11.

**9.9 > 9.11**

Thinking Off (즉시 모드):

response = client.chat.completions.create(
    model="XiaomiMiMo/MiMo-V2.5",
    messages=[
        {"role": "user", "content": "Which is larger, 9.11 or 9.9? Think carefully."}
    ],
    extra_body={"chat_template_kwargs": {"thinking": False}}
)

print(response.choices[0].message.content)

출력 예제 (MiMo-V2.5):

## Comparing 9.11 and 9.9

**9.9 is larger.**

The key is to compare them place by place. It helps to write them with the same number of decimal places:

- **9.11** → 9.11
- **9.9** → 9.90

Both have **9** in the ones place, but in the tenths place: **9** (in 9.90) is greater than **1** (in 9.11).

So **9.90 > 9.11**.

4.3 멀티모달 호출 (V2.5 전용)

이미지 이해:

from openai import OpenAI

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

response = client.chat.completions.create(
    model="XiaomiMiMo/MiMo-V2.5",
    messages=[{
        "role": "user",
        "content": [
            {"type": "image_url", "image_url": {"url": "https://raw.githubusercontent.com/sgl-project/sgl-test-files/refs/heads/main/images/man_ironing_on_back_of_suv.png"}},
            {"type": "text", "text": "Describe this image in detail."}
        ]
    }]
)

print(response.choices[0].message.content)

출력 예제:

Based on the image provided, here is a detailed description:

The image captures a whimsical or surreal scene set on a busy city street, likely in New York City given the iconic yellow cabs. In the center foreground, a man is sitting on a folding chair, casually crossing his legs. He is wearing a bright yellow hoodie with a graphic on the front and blue jeans. He is intently focused on ironing a white dress shirt that rests on an ironing board set up directly on the asphalt.

Behind him, a yellow SUV taxi cab is stopped or moving slowly, angled slightly away from the camera. To his left, another yellow taxi sedan is captured in motion blur, indicating it is driving past him. The background features tall city buildings with glass windows and storefronts. There are banners hanging from streetlights, and some greenery is visible in the distance. The overall impression is one of incongruity—performing a domestic chore like ironing in the middle of a chaotic urban environment.

비디오 이해:

response = client.chat.completions.create(
    model="XiaomiMiMo/MiMo-V2.5",
    messages=[{
        "role": "user",
        "content": [
            {"type": "video_url", "video_url": {"url": "https://videos.pexels.com/video-files/4114797/4114797-uhd_3840_2160_25fps.mp4"}},
            {"type": "text", "text": "Summarize what happens in this video."}
        ]
    }]
)

print(response.choices[0].message.content)

출력 예제:

A person wearing blue protective gloves is shown operating a microscope in a close-up shot. The individual is adjusting a knob on the side of the microscope, which moves the stage holding a glass slide, likely focusing the lens on the specimen.

비디오 디코딩에는 decord(pip install decord)가 필요해요. SGLang의 MiMo-V2.5 멀티모달 프로세서는 프레임 추출에 decord.VideoReader를 사용해요.

오디오 이해:

response = client.chat.completions.create(
    model="XiaomiMiMo/MiMo-V2.5",
    messages=[{
        "role": "user",
        "content": [
            {"type": "audio_url", "audio_url": {"url": "https://raw.githubusercontent.com/sgl-project/sgl-test-files/refs/heads/main/audios/Trump_WEF_2018_10s.mp3"}},
            {"type": "text", "text": "Transcribe and summarize this audio."}
        ]
    }]
)

print(response.choices[0].message.content)

출력 예제:

**Transcript:**

"Thank you Klaus very much. It's a privilege to be here at this forum where leaders in business, science, art, diplomacy and world affairs have gathered for..."

**Summary:**
The speaker thanks Klaus for the introduction and expresses their honor at attending a forum. They highlight that the event has brought together high-level leaders from various sectors, including business, science, art, and diplomacy.

4.4 Tool Calling

from openai import OpenAI

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

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

response = client.chat.completions.create(
    model="XiaomiMiMo/MiMo-V2.5",
    messages=[{"role": "user", "content": "What's the weather in Beijing?"}],
    tools=tools
)

msg = response.choices[0].message
if msg.reasoning_content:
    print("=== Reasoning ===")
    print(msg.reasoning_content)
if msg.tool_calls:
    print("=== Tool Calls ===")
    for tc in msg.tool_calls:
        print(f"  Function: {tc.function.name}")
        print(f"  Arguments: {tc.function.arguments}")

출력 예제 (MiMo-V2.5):

=== Reasoning ===
The user wants to know the weather in Beijing. I have a function available called "get_weather" that can retrieve current weather for a location. Let me call that function with Beijing as the location.
=== Tool Calls ===
  Function: get_weather
  Arguments: {"location": "Beijing"}

5. 벤치마크

정확도 수치는 sglang.test.run_eval(GSM8K 표준 5-shot, MMMU validation split)에서 나왔고, 속도 수치는 생성된 랜덤 프롬프트로 sglang.bench_serving에서 나왔어요. 텍스트 실행은 요청당 1024 입력 토큰과 1024 출력 토큰을, 이미지 실행은 요청당 랜덤 720p 이미지 2개를 사용해요.

5.1 정확도 벤치마크

5.1.1 GSM8K

표준 5-shot, temperature=0, max_tokens=4096, 모델은 기본적으로 thinking-on(응답에 thinking... response 포함, eval이 regex로 끝 숫자를 추출)이에요. 서버 시작: 섹션 3 참조.

벤치마크 명령:

python3 -m sglang.test.run_eval \
  --base-url http://127.0.0.1:30000 \
  --model XiaomiMiMo/MiMo-V2.5 \
  --eval-name gsm8k \
  --num-examples 200 \
  --num-threads 8 \
  --max-tokens 4096 \
  --temperature 0.0

run_eval.py는 --base-url에 /v1을 자동으로 붙여요. 뒤에 /v1이 없는 host:port URL을 전달하지 않으면 요청이 /v1/v1/chat/completions로 해석되어 404가 나요.

• 테스트 결과:
  • MiMo-V2.5-Pro (FP8, 8× B200)

    Score:             0.965  (193 / 200)
    Latency:           253.90 s
    Output throughput: 461.78 tok/s
    

  • MiMo-V2.5 (FP8, 8× H200)

    Score:             0.980  (196 / 200)
    Latency:           477.52 s
    Output throughput: 88.9 tok/s
    

5.1.2 MMMU (V2.5 전용)

MMMU/MMMU validation split(다분야 멀티모달), concurrency=16, 기본 샘플링.

• 벤치마크 명령:

python3 benchmark/mmmu/bench_sglang.py \
  --port 30000 \
  --model XiaomiMiMo/MiMo-V2.5 \
  --concurrency 16

• 테스트 결과:
  • MiMo-V2.5 (FP8)

    Pending update
    

5.2 속도 벤치마크 — MiMo-V2.5-Pro

테스트 환경:

• 하드웨어: NVIDIA B200 GPU (8×)
• 모델: XiaomiMiMo/MiMo-V2.5-Pro (FP8)
• Tensor Parallelism: 8 (단일 노드, --moe-runner-backend flashinfer_trtllm, --attention-backend fa4, --mem-fraction-static 0.8, --swa-full-tokens-ratio 0.1)
• 레시피: Blackwell 검증 기준선(이 벤치마크에서는 EAGLE 꺼짐 — 아래 참고 참조)
• sglang 버전: 0.5.11

§5.2의 수치는 random 1024/1024의 EAGLE 없는 기준선이에요. 균일 랜덤 토큰 스트림에서 MiMo-V2.5-Pro 3-레이어 MTP draft의 수락률은 매우 낮아요(~0.13–0.27, 자연어 프롬프트의 ~0.75 대비, §5.4 참조) — draft가 모델링할 토큰 공동 발생 신호가 없기 때문이에요. 그래서 이 워크로드에서는 EAGLE이 검증 오버헤드를 추가하고 draft 토큰을 충분히 회수하지 못해 순이득이 되지 않아요. EAGLE MTP 자체는 B200 + --enable-multi-layer-eagle에서 동작해요(§3 배포 명령과 §5.4 자연어 수락률 프로파일 참조).

5.2.1 지연 시간 민감 벤치마크

• 모델 배포 명령: 위 명령 패널 참조.
• 벤치마크 명령:

python3 -m sglang.bench_serving \
  --backend sglang \
  --host 127.0.0.1 \
  --port 30000 \
  --model XiaomiMiMo/MiMo-V2.5-Pro \
  --random-input-len 1024 \
  --random-output-len 1024 \
  --num-prompts 10 \
  --max-concurrency 1

• 테스트 결과:

============ Serving Benchmark Result ============
Backend:                                 sglang
Traffic request rate:                    inf
Max request concurrency:                 1
Successful requests:                     10
Benchmark duration (s):                  27.59
Total input tokens:                      1997
Total input text tokens:                 1997
Total generated tokens:                  2798
Total generated tokens (retokenized):    2794
Request throughput (req/s):              0.36
Input token throughput (tok/s):          72.38
Output token throughput (tok/s):         101.41
Peak output token throughput (tok/s):    110.00
Peak concurrent requests:                3
Total token throughput (tok/s):          173.79
Concurrency:                             1.00
----------------End-to-End Latency----------------
Mean E2E Latency (ms):                   2757.26
Median E2E Latency (ms):                 3319.10
P90 E2E Latency (ms):                    4157.47
P99 E2E Latency (ms):                    4869.32
---------------Time to First Token----------------
Mean TTFT (ms):                          162.17
Median TTFT (ms):                        68.11
P99 TTFT (ms):                           929.58
-----Time per Output Token (excl. 1st token)------
Mean TPOT (ms):                          9.19
Median TPOT (ms):                        9.33
P99 TPOT (ms):                           9.39
---------------Inter-Token Latency----------------
Mean ITL (ms):                           9.31
Median ITL (ms):                         9.35
P95 ITL (ms):                            9.44
P99 ITL (ms):                            9.77
Max ITL (ms):                            19.80
==================================================

5.2.2 처리량 민감 벤치마크

• 모델 배포 명령: 위 명령 패널 참조.
• 벤치마크 명령:

python3 -m sglang.bench_serving \
  --backend sglang \
  --host 127.0.0.1 \
  --port 30000 \
  --model XiaomiMiMo/MiMo-V2.5-Pro \
  --random-input-len 1024 \
  --random-output-len 1024 \
  --num-prompts 1000 \
  --max-concurrency 100

• 테스트 결과:

============ Serving Benchmark Result ============
Backend:                                 sglang
Traffic request rate:                    inf
Max request concurrency:                 100
Successful requests:                     1000
Benchmark duration (s):                  112.78
Total input tokens:                      302118
Total input text tokens:                 302118
Total generated tokens:                  195775
Total generated tokens (retokenized):    191069
Request throughput (req/s):              8.87
Input token throughput (tok/s):          2678.83
Output token throughput (tok/s):         1735.90
Peak output token throughput (tok/s):    3040.00
Peak concurrent requests:                121
Total token throughput (tok/s):          4414.73
Concurrency:                             87.80
----------------End-to-End Latency----------------
Mean E2E Latency (ms):                   9901.96
Median E2E Latency (ms):                 6525.54
P90 E2E Latency (ms):                    23567.98
P99 E2E Latency (ms):                    42109.22
---------------Time to First Token----------------
Mean TTFT (ms):                          223.69
Median TTFT (ms):                        139.45
P99 TTFT (ms):                           1082.02
-----Time per Output Token (excl. 1st token)------
Mean TPOT (ms):                          50.63
Median TPOT (ms):                        51.66
P99 TPOT (ms):                           91.41
---------------Inter-Token Latency----------------
Mean ITL (ms):                           49.79
Median ITL (ms):                         33.69
P95 ITL (ms):                            103.37
P99 ITL (ms):                            151.34
Max ITL (ms):                            1600.00
==================================================

5.3 속도 벤치마크 — MiMo-V2.5

테스트 환경:

• 하드웨어: NVIDIA H200 GPU (8×)
• 모델: XiaomiMiMo/MiMo-V2.5 (FP8)
• Tensor Parallelism: 8 (DP-attention with --dp 2)
• 레시피: Balanced (DP-attn + EAGLE MTP)
• sglang 버전: 0.0.0.dev1+g7d99af439 (lmsysorg/sglang:dev-mimo-v2.5)

5.3.1 지연 시간 민감 벤치마크

• 모델 배포 명령: 위 명령 패널에서 MiMo-V2.5, H200, EAGLE MTP를 선택.
• 벤치마크 명령:

python3 -m sglang.bench_serving \
  --backend sglang \
  --host 127.0.0.1 \
  --port 30000 \
  --model XiaomiMiMo/MiMo-V2.5 \
  --random-input-len 1024 \
  --random-output-len 1024 \
  --num-prompts 10 \
  --max-concurrency 1

• 테스트 결과:

============ Serving Benchmark Result ============
Backend:                                 sglang
Traffic request rate:                    inf
Max request concurrency:                 1
Successful requests:                     10
Benchmark duration (s):                  14.72
Total input tokens:                      1997
Total input text tokens:                 1997
Total generated tokens:                  2798
Total generated tokens (retokenized):    2697
Request throughput (req/s):              0.68
Input token throughput (tok/s):          135.67
Output token throughput (tok/s):         190.09
Peak output token throughput (tok/s):    245.00
Peak concurrent requests:                3
Total token throughput (tok/s):          325.77
Concurrency:                             1.00
Accept length:                           3.08
----------------End-to-End Latency----------------
Mean E2E Latency (ms):                   1469.98
Median E2E Latency (ms):                 1652.84
P90 E2E Latency (ms):                    2210.80
P99 E2E Latency (ms):                    2823.86
---------------Time to First Token----------------
Mean TTFT (ms):                          143.89
Median TTFT (ms):                        99.25
P99 TTFT (ms):                           481.01
-----Time per Output Token (excl. 1st token)------
Mean TPOT (ms):                          4.87
Median TPOT (ms):                        4.30
P99 TPOT (ms):                           6.64
---------------Inter-Token Latency----------------
Mean ITL (ms):                           4.76
Median ITL (ms):                         3.46
P95 ITL (ms):                            13.52
P99 ITL (ms):                            13.84
Max ITL (ms):                            74.37
==================================================

5.3.2 처리량 민감 벤치마크

• 모델 배포 명령: 위 명령 패널에서 MiMo-V2.5, H200, EAGLE MTP를 선택.
• 벤치마크 명령:

python3 -m sglang.bench_serving \
  --backend sglang \
  --host 127.0.0.1 \
  --port 30000 \
  --model XiaomiMiMo/MiMo-V2.5 \
  --random-input-len 1024 \
  --random-output-len 1024 \
  --num-prompts 1000 \
  --max-concurrency 100

• 테스트 결과:

============ Serving Benchmark Result ============
Backend:                                 sglang
Traffic request rate:                    inf
Max request concurrency:                 100
Successful requests:                     1000
Benchmark duration (s):                  93.41
Total input tokens:                      302118
Total input text tokens:                 302118
Total generated tokens:                  195775
Total generated tokens (retokenized):    188139
Request throughput (req/s):              10.71
Input token throughput (tok/s):          3234.48
Output token throughput (tok/s):         2095.97
Peak output token throughput (tok/s):    3019.00
Peak concurrent requests:                121
Total token throughput (tok/s):          5330.45
Concurrency:                             91.04
Accept length:                           2.95
----------------End-to-End Latency----------------
Mean E2E Latency (ms):                   8503.45
Median E2E Latency (ms):                 7491.96
P90 E2E Latency (ms):                    13706.99
P99 E2E Latency (ms):                    20474.33
---------------Time to First Token----------------
Mean TTFT (ms):                          4399.20
Median TTFT (ms):                        4333.35
P99 TTFT (ms):                           8004.81
-----Time per Output Token (excl. 1st token)------
Mean TPOT (ms):                          58.23
Median TPOT (ms):                        21.78
P99 TPOT (ms):                           747.79
---------------Inter-Token Latency----------------
Mean ITL (ms):                           20.06
Median ITL (ms):                         15.28
P95 ITL (ms):                            48.36
P99 ITL (ms):                            96.99
Max ITL (ms):                            969.61
==================================================

5.3.3 멀티모달 (이미지) 벤치마크

• 모델 배포 명령: 위 명령 패널에서 MiMo-V2.5, H200, EAGLE MTP를 선택.
• 벤치마크 명령:

python3 -m sglang.bench_serving \
  --backend sglang-oai-chat \
  --host 127.0.0.1 \
  --port 30000 \
  --model XiaomiMiMo/MiMo-V2.5 \
  --dataset-name image \
  --image-count 2 \
  --image-resolution 720p \
  --random-input-len 128 \
  --random-output-len 1024 \
  --num-prompts 10 \
  --max-concurrency 1

• 테스트 결과:

============ Serving Benchmark Result ============
Backend:                                 sglang-oai-chat
Traffic request rate:                    inf
Max request concurrency:                 1
Successful requests:                     10
Benchmark duration (s):                  25.73
Total input tokens:                      661
Total input text tokens:                 631
Total input vision tokens:               30
Total generated tokens:                  4220
Total generated tokens (retokenized):    0
Request throughput (req/s):              0.39
Input token throughput (tok/s):          25.69
Output token throughput (tok/s):         164.03
Peak output token throughput (tok/s):    1.00
Peak concurrent requests:                2
Total token throughput (tok/s):          189.73
Concurrency:                             1.00
Accept length:                           2.94
----------------End-to-End Latency----------------
Mean E2E Latency (ms):                   2570.74
Median E2E Latency (ms):                 2411.92
P90 E2E Latency (ms):                    3711.62
P99 E2E Latency (ms):                    4949.74
---------------Time to First Token----------------
Mean TTFT (ms):                          0.00
Median TTFT (ms):                        0.00
P99 TTFT (ms):                           0.00
-----Time per Output Token (excl. 1st token)------
Mean TPOT (ms):                          7.31
Median TPOT (ms):                        6.17
P99 TPOT (ms):                           17.18
---------------Inter-Token Latency----------------
Mean ITL (ms):                           0.00
Median ITL (ms):                         0.00
P95 ITL (ms):                            0.00
P99 ITL (ms):                            0.00
Max ITL (ms):                            0.00
==================================================

5.4 Multi-Layer EAGLE 수락률 프로파일 — MiMo-V2.5-Pro

Pro의 3-레이어 MTP는 자연어와 균일 랜덤 토큰 스트림에서 매우 다르게 동작해요. §5.2 벤치마크는 수락률을 붕괴시키는 random 1024/1024를 사용하고, 이 섹션은 GSM8K에서 같은 서버를 측정해 수락률 숫자가 실제 워크로드와 비교 가능하게 해요.

테스트 환경:

• 하드웨어: NVIDIA B200 GPU (8×)
• 모델: XiaomiMiMo/MiMo-V2.5-Pro (FP8)
• Tensor Parallelism: 8 (단일 노드, --moe-runner-backend flashinfer_trtllm, --attention-backend fa4, --mem-fraction-static 0.8, --swa-full-tokens-ratio 0.1)
• 레시피: 3-레이어 EAGLE — --enable-multi-layer-eagle --speculative-num-steps 3 --speculative-eagle-topk 1 --speculative-num-draft-tokens 4 (top-1, 최대 수락 길이 4)

벤치마크 명령:

python3 -m sglang.test.run_eval \
  --base-url http://127.0.0.1:30000 \
  --model XiaomiMiMo/MiMo-V2.5-Pro \
  --eval-name gsm8k \
  --num-examples 200 \
  --num-threads 4

아래 accept_rate와 accept_length 행은 run_eval 자체 출력이 아니라, GSM8K 실행(총 307 배치) 중 발생한 서버 측 Decode batch ... accept rate: X accept len: Y 로그 라인에서 집계된 값이에요.

GSM8K Score: 0.97 (194 / 200), 이 단일 서버 실행에서 출력 처리량 ≈ 635 tok/s end-to-end.

수락률 격차는 MTP 스타일 추측 디코딩의 고유한 특성이에요. draft 모델은 자연어 토큰 분포로 훈련되어 균일 랜덤 바이트 시퀀스에서는 유용한 신호가 없어요. 구조가 있는 워크로드(채팅, 코드, 추론 추적)는 GSM8K급 숫자를 기대해야 하고, §5.2의 랜덤 프롬프트 기준선은 draft 수락의 최악의 경우예요.

5.5 장문 컨텍스트 Prefill & MTP Decode — MiMo-V2.5-Pro (참고)

day0 enablement PR의 참고 수치로, EP=16, DP=2, TP=16 레시피(--moe-a2a-backend deepep, --attention-backend fa3, --enable-multi-layer-eagle)로 2노드 Hopper 배포에서 수집했어요. 설정, 병렬 처리, 벤치마크 방법론이 모두 §5.2(Blackwell TP=8, random 1024/1024)와 다르므로, §5.2와의 비교가 아니라 별도의 운영 지점(장문 컨텍스트 prefill 스케일링과 MTP 디코드 속도 향상)으로 취급하세요.

테스트 환경:

• 하드웨어: NVIDIA Hopper GPU (2 노드 × 8 GPU, GPU SKU는 의도적으로 공개 안 함)
• 모델: XiaomiMiMo/MiMo-V2.5-Pro (FP8)
• 병렬 처리: --tp 16 --dp 2 --ep 16 --moe-dense-tp-size 1 --enable-dp-attention
• 레시피: Hopper EP16 (DeepEP + EAGLE multi-layer MTP)

5.5.1 장문 컨텍스트 Prefill 처리량

테스트 설정: chunked_prefill_size=32K, random_output_len=1, 매 실행 전 캐시 플러시. 입력 길이 ≥ 512K에서는 워크로드를 두 요청으로 분할해 서로 다른 DP 랭크로 라우팅하고 노드별 처리량을 bench_serving 출력에서 읽었어요.

• 벤치마크 명령:

python3 -m sglang.bench_serving \
  --backend sglang \
  --model XiaomiMiMo/MiMo-V2.5-Pro \
  --host 0.0.0.0 \
  --port 30000 \
  --dataset-name random \
  --random-input-len <INPUT_LEN> \
  --random-output-len 1 \
  --random-range-ratio 1.0 \
  --flush-cache \
  --seed 12345 \
  --num-prompts 10000

• 테스트 결과 — 단일 노드 prefill 처리량, cache-miss:

Prefill 처리량은 4K에서 32K까지 피크의 ~10% 내에 유지되고 128K 이후로는 완만하게 저하되어, 하이브리드 SWA+GA 어텐션이 1M 컨텍스트에서 올바르게 동작함을 확인해줘요.

5.5.2 Decode 처리량 — MTP 속도 향상

테스트 설정: 고정 16K 입력 / 1K 출력, DP 랭크별 배치 크기 변화, 3-레이어 MTP 모듈 있음/없음. MTP accept length는 EAGLE 추측 디코딩 아래 단계당 평균 수락 draft 토큰 수예요. TPS는 요청별 출력 토큰/초(즉 단일 사용자 인지 속도)이고, 가장 오른쪽 열은 집계된 단일 노드 decode 처리량(= TPS × 배치 크기)이에요.

• 테스트 결과 — 단일 노드 decode 처리량:

요약 — MTP on / off:

3-레이어 MTP 모듈은 수락 길이 3에서 ~2×, 수락 길이 4에서 ~2.5–2.7×의 디코드 처리량을 제공해요 — §3.2의 "2–3× decode speedup" 지침과 같은 크기예요.

더 알아보기 (Learn more)

• MiMo-V2.5-Pro · MiMo-V2.5
• sgl-jax · DeepEP
• SGLang 설치 가이드