Nemotron 3 Nano Omni

Nemotron 3 Nano Omni (NVIDIA)

Nemotron 3 Nano Omni는 NVIDIA의 30B 파라미터 하이브리드 MoE 멀티모달 모델로, forward pass마다 3B 파라미터만 활성화하고 비전·오디오 인코더를 통합한 아키텍처를 가져요. 단일 추론 루프에서 비전, 오디오, 언어를 함께 지각하고 추론하는 멀티모달 하위 에이전트를 구동하도록 설계되었어요. 이 페이지에서 SGLang 배포·호출 방법을 설명해요.

출처: 문서

본문

1. Model Introduction (모델 소개)

NVIDIA Nemotron 3 Nano Omni는 30B 파라미터 하이브리드 MoE 멀티모달 모델로, forward pass마다 3B 파라미터만 활성화하고 비전·오디오 인코더를 통합한 아키텍처를 가져요. Nemotron 3 제품군의 일부로, 비전·오디오·언어를 단일 추론 루프에서 지각하고 추론하는 멀티모달 하위 에이전트 구동을 위해 설계되어 각 모달리티별 분리된 모델 스택의 단편화를 제거해요.

아키텍처와 주요 특징:

  • 하이브리드 Transformer-Mamba 아키텍처 (MoE): 효율적 라우팅과 시퀀스 모델링을 위해 MoE와 하이브리드 Transformer-Mamba 아키텍처를 결합.
  • 총 30B / 활성 3B 파라미터: dense 모델의 비용 일부로 강력한 멀티모달 정확도 제공.
  • 1M 토큰 컨텍스트 윈도우: 화면 기록, 문서 내용, 오디오 컨텍스트를 재섭취 없이 유지하며 확장된 멀티모달 워크플로 전반에서 일관된 에이전트 상태 유지.
  • 통합 비전·오디오 인코더: 하나의 모델이 단편화된 멀티모달 스택을 대체. 비전·오디오 지각이 같은 forward pass에서 발생.
  • 3D 컨볼루션 (Conv3D): 비디오 입력을 위한 효율적 시간-공간 처리.
  • 효율적 비디오 샘플링 (EVS): 시간 인식 지각과 적응형 프레임 샘플링으로 같은 컴퓨트 예산에서 더 긴 비디오 처리 지원.
  • FP8 및 NVFP4 양자화: FP8은 워크스테이션(RTX 6000, DGX Spark)부터 클라우드(H100, H200, B200, A100, L40S)까지 배포 지원. NVFP4는 Blackwell 하드웨어 필요.
  • 다른 오픈 omni 모델 대비 같은 인터랙티비티 수준에서 9배 높은 처리량.
  • 최고의 오픈 대안 대비 약 20% 높은 멀티모달 지능.
  • NVIDIA NeMo RL과 NeMo Gym을 통한 다중 환경 강화학습으로 post-trained, 텍스트·이미지·오디오·비디오 환경에 걸쳐 지시 수행과 올바른 멀티모달 답변 수렴을 개선.

모달리티: 입력: text, image, video, audio — 출력: text

지원 GPU: NVIDIA B200, H100, H200, A100, L40S, DGX Spark, RTX 6000

HuggingFace의 모델 변형:

이 모델이 가능하게 하는 에이전트 워크로드:

  • Computer Use Agent: GUI를 탐색하는 에이전트의 지각 루프 — 화면을 읽고 시간에 따른 UI 상태를 이해하며 결과를 검증. 비전과 추론을 단일 루프로 통합.
  • Document Intelligence: 문서, 차트, 표, 스크린샷, 혼합 미디어 입력을 해석해 기업 분석과 컴플라이언스 워크플로 지원.
  • Audio & Video Understanding Agents: 고객 서비스, 연구, 모니터링 워크플로를 위한 연속 오디오-비디오 컨텍스트 유지 — 말해진 것, 보여진 것, 문서화된 것을 단일 추론 스트림으로 연결.

2. SGLang Installation (SGLang 설치)

pip 또는 소스에서 SGLang을 설치해요.

# Install via pip
pip install sglang

# Or install from source
uv pip install --prerelease=allow 'git+https://github.com/sgl-project/sglang.git#subdirectory=python'

# Or use Docker
docker pull lmsysorg/sglang:latest

전체 Docker 설정과 다른 설치 방법은 공식 SGLang 설치 가이드를 참고해요.

3. Model Deployment (모델 배포)

이 섹션은 빠른 배포부터 성능 튜닝까지 단계별로 안내해요.

3.1 Basic Configuration

인터랙티브 명령 생성기: 하드웨어, 모델 변형, 일반 노브를 선택해 실행 명령을 생성해요.

3.2 Configuration Tips

  • Attention backend:

    H100/H200: 기본적으로 flash attention 3 backend 사용. B200: 기본적으로 flashinfer backend 사용.

  • TP 지원:

    텐서 병렬화는 --tp <1|2|4|8>로 설정해요. BF16 변형은 4×H100 설정을 권장해요.

  • FP8 KV cache:

    FP8 KV cache를 활성화하려면 --kv-cache-dtype fp8_e4m3을 추가해요. FP8 KV cache는 약간의 정확도를 메모리로 바꿔요. 워크로드에서 정확도 저하가 보이면 이 플래그를 빼요.

  • 추론 파서:

    --reasoning-parser deepseek-r1을 추가해 구조화된 추론 트레이스(응답의 reasoning_content 필드)를 활성화해요.

  • 툴 호출:

    --tool-call-parser qwen3_coder를 추가해 툴 호출 지원을 활성화해요.

4. Model Invocation (모델 호출)

아래 명령은 추론과 툴 호출을 활성화한 4×H100 설정으로 서버를 실행해요. FP8·NVFP4 변형은 Section 4.8을 참고해요.

sglang serve \
  --model-path nvidia/Nemotron-3-Nano-Omni-30B-A3B-Reasoning-BF16 \
  --host 0.0.0.0 \
  --port 30000 \
  --tp 4 \
  --trust-remote-code \
  --tool-call-parser qwen3_coder \
  --reasoning-parser deepseek-r1

4.1 Basic Usage (Text)

SGLang은 OpenAI 호환 엔드포인트를 제공해요. OpenAI Python 클라이언트 예제:

from openai import OpenAI

SERVED_MODEL_NAME = "nvidia/Nemotron-3-Nano-Omni-30B-A3B-Reasoning-BF16"
client = OpenAI(base_url="http://localhost:30000/v1", api_key="EMPTY")

resp = client.chat.completions.create(
    model=SERVED_MODEL_NAME,
    messages=[
        {"role": "system", "content": "You are a helpful AI assistant."},
        {"role": "user", "content": "Give me 3 bullet points about SGLang."},
    ],
    temperature=0.6,
    max_tokens=512,
)
print(resp.choices[0].message.reasoning_content, resp.choices[0].message.content)

출력:

Reasoning: SGLang is a serving framework I know from my training data. Let me recall the key features...

Content:
- **Radix Attention** — SGLang reuses KV cache across requests sharing a common prefix, dramatically reducing memory and compute for multi-turn and few-shot workloads.
- **OpenAI-compatible API** — Drop-in replacement for the OpenAI Python client; no application code changes required to serve a locally-hosted model.
- **High-throughput serving** — Continuous batching, chunked prefill, and optimized CUDA kernels deliver state-of-the-art throughput on NVIDIA GPUs across A100, H100, and B200.

스트리밍 채팅 완성:

from openai import OpenAI

SERVED_MODEL_NAME = "nvidia/Nemotron-3-Nano-Omni-30B-A3B-Reasoning-BF16"
client = OpenAI(base_url="http://localhost:30000/v1", api_key="EMPTY")

stream = client.chat.completions.create(
    model=SERVED_MODEL_NAME,
    messages=[
        {"role": "system", "content": "You are a helpful AI assistant."},
        {"role": "user", "content": "What are the first 5 prime numbers?"},
    ],
    temperature=0.6,
    max_tokens=512,
    stream=True,
)
for chunk in stream:
    delta = chunk.choices[0].delta
    if delta and delta.content:
        print(delta.content, end="", flush=True)

4.2 Image Understanding (이미지 이해)

OpenAI 비전 형식으로 이미지 입력을 전달해요. URL과 base64 인코딩 이미지를 모두 지원해요.

from openai import OpenAI

SERVED_MODEL_NAME = "nvidia/Nemotron-3-Nano-Omni-30B-A3B-Reasoning-BF16"
client = OpenAI(base_url="http://localhost:30000/v1", api_key="EMPTY")

# From URL
resp = client.chat.completions.create(
    model=SERVED_MODEL_NAME,
    messages=[
        {
            "role": "user",
            "content": [
                {
                    "type": "image_url",
                    "image_url": {"url": "https://upload.wikimedia.org/wikipedia/commons/thumb/3/3a/Cat03.jpg/1200px-Cat03.jpg"},
                },
                {"type": "text", "text": "Describe this image in detail."},
            ],
        }
    ],
    temperature=0.6,
    max_tokens=512,
)
print(resp.choices[0].message.reasoning_content)
print(resp.choices[0].message.content)

로컬 이미지는 base64로 인코딩해요:

import base64
from openai import OpenAI

SERVED_MODEL_NAME = "nvidia/Nemotron-3-Nano-Omni-30B-A3B-Reasoning-BF16"
client = OpenAI(base_url="http://localhost:30000/v1", api_key="EMPTY")

with open("screenshot.png", "rb") as f:
    image_b64 = base64.b64encode(f.read()).decode("utf-8")

resp = client.chat.completions.create(
    model=SERVED_MODEL_NAME,
    messages=[
        {
            "role": "user",
            "content": [
                {
                    "type": "image_url",
                    "image_url": {"url": f"data:image/png;base64,{image_b64}"},
                },
                {"type": "text", "text": "What UI elements are visible on this screen? What action would you take next?"},
            ],
        }
    ],
    temperature=0.6,
    max_tokens=512,
)
print(resp.choices[0].message.content)

4.3 Video Understanding (비디오 이해)

Nemotron 3 Nano Omni는 시간-공간 비디오 추론을 위해 Conv3D 레이어와 Efficient Video Sampling (EVS)을 사용하며, 같은 컴퓨트 예산으로 더 긴 비디오를 처리해요.

import base64
from openai import OpenAI

SERVED_MODEL_NAME = "nvidia/Nemotron-3-Nano-Omni-30B-A3B-Reasoning-BF16"
client = OpenAI(base_url="http://localhost:30000/v1", api_key="EMPTY")

with open("video.mp4", "rb") as f:
    video_b64 = base64.b64encode(f.read()).decode("utf-8")

resp = client.chat.completions.create(
    model=SERVED_MODEL_NAME,
    messages=[
        {
            "role": "user",
            "content": [
                {
                    "type": "video_url",
                    "video_url": {"url": f"data:video/mp4;base64,{video_b64}"},
                },
                {"type": "text", "text": "Summarize what happens in this video step by step."},
            ],
        }
    ],
    temperature=0.6,
    max_tokens=1024,
)
print(resp.choices[0].message.reasoning_content)
print(resp.choices[0].message.content)

4.4 Audio Understanding (오디오 이해)

오디오 입력을 base64 인코딩 WAV 또는 MP3 데이터로 전달해요.

import base64
from openai import OpenAI

SERVED_MODEL_NAME = "nvidia/Nemotron-3-Nano-Omni-30B-A3B-Reasoning-BF16"
client = OpenAI(base_url="http://localhost:30000/v1", api_key="EMPTY")

with open("audio.wav", "rb") as f:
    audio_b64 = base64.b64encode(f.read()).decode("utf-8")

resp = client.chat.completions.create(
    model=SERVED_MODEL_NAME,
    messages=[
        {
            "role": "user",
            "content": [
                {
                    "type": "input_audio",
                    "input_audio": {"data": audio_b64, "format": "wav"},
                },
                {"type": "text", "text": "Transcribe and summarize what was said in this audio."},
            ],
        }
    ],
    temperature=0.6,
    max_tokens=512,
)
print(resp.choices[0].message.content)

4.5 Mixed Multimodal Input (혼합 멀티모달 입력)

단일 요청에서 여러 모달리티를 결합해요. 예: 이미지에 대한 오디오 질문과 함께 이미지를 제공.

import base64
from openai import OpenAI

SERVED_MODEL_NAME = "nvidia/Nemotron-3-Nano-Omni-30B-A3B-Reasoning-BF16"
client = OpenAI(base_url="http://localhost:30000/v1", api_key="EMPTY")

with open("chart.png", "rb") as f:
    image_b64 = base64.b64encode(f.read()).decode("utf-8")

resp = client.chat.completions.create(
    model=SERVED_MODEL_NAME,
    messages=[
        {
            "role": "user",
            "content": [
                {
                    "type": "image_url",
                    "image_url": {"url": f"data:image/png;base64,{image_b64}"},
                },
                {"type": "text", "text": "Analyze this chart. What are the key trends and what conclusion does the data support?"},
            ],
        }
    ],
    temperature=0.6,
    max_tokens=1024,
)
print(resp.choices[0].message.reasoning_content)
print(resp.choices[0].message.content)

4.6 Reasoning (추론)

모델은 Reasoning ON(기본값) vs OFF의 두 가지 모드를 지원해요. enable_thinking을 False로 설정해 요청별로 전환해요.

from openai import OpenAI

SERVED_MODEL_NAME = "nvidia/Nemotron-3-Nano-Omni-30B-A3B-Reasoning-BF16"
client = OpenAI(base_url="http://localhost:30000/v1", api_key="EMPTY")

# Reasoning ON (default)
print("Reasoning on")
resp = client.chat.completions.create(
    model=SERVED_MODEL_NAME,
    messages=[
        {"role": "system", "content": "You are a helpful assistant."},
        {"role": "user", "content": "What is the derivative of x^3 sin(x)?"},
    ],
    temperature=0.6,
    max_tokens=1024,
)
print(f"Reasoning:\n{resp.choices[0].message.reasoning_content[:300]}...\nContent:\n{resp.choices[0].message.content}")
print("\n")

# Reasoning OFF
print("Reasoning off")
resp = client.chat.completions.create(
    model=SERVED_MODEL_NAME,
    messages=[
        {"role": "system", "content": "You are a helpful assistant."},
        {"role": "user", "content": "What is 15% of 200?"},
    ],
    temperature=0.6,
    max_tokens=256,
    extra_body={"chat_template_kwargs": {"enable_thinking": False}},
)
print(f"Content:\n{resp.choices[0].message.content}")

출력:

Reasoning on
Reasoning:
The user wants the derivative of x^3 sin(x). I'll apply the product rule: d/dx[u·v] = u'v + uv'. Here u = x^3, v = sin(x). So u' = 3x^2, v' = cos(x). The result is 3x^2·sin(x) + x^3·cos(x)...
Content:
Using the product rule: d/dx[x³ sin(x)] = 3x² sin(x) + x³ cos(x)


Reasoning off
Content:
15% of 200 is **30**.

4.7 Tool Calling (툴 호출)

OpenAI Tools 스키마로 함수를 호출해요. 서버는 --tool-call-parser qwen3_coder로 실행되어야 해요.

from openai import OpenAI

SERVED_MODEL_NAME = "nvidia/Nemotron-3-Nano-Omni-30B-A3B-Reasoning-BF16"
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 and state, e.g. San Francisco, CA",
                    },
                    "unit": {
                        "type": "string",
                        "enum": ["celsius", "fahrenheit"],
                    },
                },
                "required": ["location"],
            },
        },
    }
]

completion = client.chat.completions.create(
    model=SERVED_MODEL_NAME,
    messages=[
        {"role": "system", "content": "You are a helpful assistant."},
        {"role": "user", "content": "What is the weather like in Santa Clara, CA?"},
    ],
    tools=TOOLS,
    temperature=0.6,
    top_p=0.95,
    max_tokens=512,
    stream=False,
)
print(completion.choices[0].message.reasoning_content)
print(completion.choices[0].message.tool_calls)

출력:

The user is asking about weather in Santa Clara, CA. I have a get_weather function that takes a location and optional unit. I should call it with location="Santa Clara, CA".

[ChatCompletionMessageFunctionToolCall(id='call_abc123', function=Function(arguments='{"location": "Santa Clara, CA", "unit": "fahrenheit"}', name='get_weather'), type='function', index=0)]

4.8 FP8 and NVFP4 Deployment (FP8 및 NVFP4 배포)

FP8 변형 (H100/H200/B200에서 처리량-중요 서빙 권장):

sglang serve \
  --model-path nvidia/Nemotron-3-Nano-Omni-30B-A3B-Reasoning-FP8 \
  --host 0.0.0.0 \
  --port 30000 \
  --tp 4 \
  --trust-remote-code \
  --tool-call-parser qwen3_coder \
  --reasoning-parser deepseek-r1

NVFP4 변형 (Blackwell B200에서 최대 효율):

sglang serve \
  --model-path nvidia/Nemotron-3-Nano-Omni-30B-A3B-Reasoning-NVFP4 \
  --host 0.0.0.0 \
  --port 30000 \
  --tp 4 \
  --trust-remote-code \
  --tool-call-parser qwen3_coder \
  --reasoning-parser deepseek-r1

5. Benchmark (벤치마크)

5.1 Efficiency Benchmark (효율 벤치마크)

Nemotron 3 Nano Omni는 다른 오픈 omni 모델보다 같은 인터랙티비티 수준에서 9배 높은 처리량을 달성하며, 응답성을 희생하지 않고 더 낮은 비용과 더 나은 확장성을 제공해요. 또한 이미지·비디오·오디오 추론 작업 전반에서 최고의 오픈 대안 대비 약 20% 높은 멀티모달 지능을 달성해요.

5.2 Speed Benchmark (속도 벤치마크)

테스트 환경:

  • Hardware: B200 (8×)
  • Model: nvidia/Nemotron-3-Nano-Omni-30B-A3B-Reasoning
  • Tensor Parallelism: 4
  • SGLang Version: main branch

모델 배포 명령:

sglang serve \
  --model-path nvidia/Nemotron-3-Nano-Omni-30B-A3B-Reasoning-BF16 \
  --trust-remote-code \
  --tp 4 \
  --max-running-requests 1024 \
  --host 0.0.0.0 \
  --attention-backend flashinfer \
  --port 30000

벤치마크 명령:

python3 -m sglang.bench_serving \
  --backend sglang \
  --host 127.0.0.1 \
  --port 30000 \
  --model nvidia/Nemotron-3-Nano-Omni-30B-A3B-Reasoning-BF16 \
  --dataset-name random \
  --random-input-len 1024 \
  --random-output-len 1024 \
  --num-prompts 4096 \
  --max-concurrency 256
  • 테스트 결과:
============ Serving Benchmark Result ============
Backend:                                 sglang
Traffic request rate:                    inf
Max request concurrency:                 256
Successful requests:                     4096
Benchmark duration (s):                  206.52
Total input tokens:                      2081726
Total input text tokens:                 2081726
Total generated tokens:                  2087288
Total generated tokens (retokenized):    1945477
Request throughput (req/s):              19.83
Input token throughput (tok/s):          10080.25
Output token throughput (tok/s):         10107.18
Peak output token throughput (tok/s):    20199.00
Peak concurrent requests:                291
Total token throughput (tok/s):          20187.44
Concurrency:                             250.83
----------------End-to-End Latency----------------
Mean E2E Latency (ms):                   12646.47
Median E2E Latency (ms):                 12371.84
P90 E2E Latency (ms):                    22889.81
P99 E2E Latency (ms):                    26528.70
---------------Time to First Token----------------
Mean TTFT (ms):                          220.66
Median TTFT (ms):                        97.67
P99 TTFT (ms):                           2068.63
-----Time per Output Token (excl. 1st token)------
Mean TPOT (ms):                          24.98
Median TPOT (ms):                        24.36
P99 TPOT (ms):                           44.97
---------------Inter-Token Latency----------------
Mean ITL (ms):                           24.43
Median ITL (ms):                         10.91
P95 ITL (ms):                            62.68
P99 ITL (ms):                            100.60
Max ITL (ms):                            2171.93
==================================================

5.3 Accuracy Benchmark (정확도 벤치마크)

환경

  • Hardware: B200 (8×)
  • Model: nvidia/Nemotron-3-Nano-Omni-30B-A3B-Reasoning
  • Tensor Parallelism: 4
  • SGLang Version: main branch

모델 실행

sglang serve \
  --model-path nvidia/Nemotron-3-Nano-Omni-30B-A3B-Reasoning-BF16 \
  --trust-remote-code \
  --tp 4 \
  --attention-backend flashinfer \
  --reasoning-parser deepseek-r1

5.3.1 GSM8K Benchmark

벤치마크 실행

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

테스트 결과:

Accuracy: 0.830
Invalid: 0.000
Latency: 13.970 s
Output throughput: 1611.623 token/s

5.3.2 MMLU Benchmark

벤치마크 실행

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

테스트 결과:

subject: abstract_algebra, #q:100, acc: 0.510
subject: anatomy, #q:135, acc: 0.711
subject: astronomy, #q:152, acc: 0.829
subject: business_ethics, #q:100, acc: 0.760
subject: clinical_knowledge, #q:265, acc: 0.781
subject: college_biology, #q:144, acc: 0.854
subject: college_chemistry, #q:100, acc: 0.560
subject: college_computer_science, #q:100, acc: 0.700
subject: college_mathematics, #q:100, acc: 0.590
subject: college_medicine, #q:173, acc: 0.775
subject: college_physics, #q:102, acc: 0.559
subject: computer_security, #q:100, acc: 0.750
subject: conceptual_physics, #q:235, acc: 0.821
subject: econometrics, #q:114, acc: 0.605
subject: electrical_engineering, #q:145, acc: 0.759
subject: elementary_mathematics, #q:378, acc: 0.638
subject: formal_logic, #q:126, acc: 0.524
subject: global_facts, #q:100, acc: 0.400
subject: high_school_biology, #q:310, acc: 0.906
subject: high_school_chemistry, #q:203, acc: 0.759
subject: high_school_computer_science, #q:100, acc: 0.860
subject: high_school_european_history, #q:165, acc: 0.812
subject: high_school_geography, #q:198, acc: 0.889
subject: high_school_government_and_politics, #q:193, acc: 0.933
subject: high_school_macroeconomics, #q:390, acc: 0.785
subject: high_school_mathematics, #q:270, acc: 0.496
subject: high_school_microeconomics, #q:238, acc: 0.887
subject: high_school_physics, #q:151, acc: 0.675
subject: high_school_psychology, #q:545, acc: 0.895
subject: high_school_statistics, #q:216, acc: 0.731
subject: high_school_us_history, #q:204, acc: 0.858
subject: high_school_world_history, #q:237, acc: 0.873
subject: human_aging, #q:223, acc: 0.740
subject: human_sexuality, #q:131, acc: 0.855
subject: international_law, #q:121, acc: 0.851
subject: jurisprudence, #q:108, acc: 0.815
subject: logical_fallacies, #q:163, acc: 0.847
subject: machine_learning, #q:112, acc: 0.598
subject: management, #q:103, acc: 0.864
subject: marketing, #q:234, acc: 0.910
subject: medical_genetics, #q:100, acc: 0.880
subject: miscellaneous, #q:783, acc: 0.881
subject: moral_disputes, #q:346, acc: 0.780
subject: moral_scenarios, #q:895, acc: 0.543
subject: nutrition, #q:306, acc: 0.814
subject: philosophy, #q:311, acc: 0.733
subject: prehistory, #q:324, acc: 0.852
subject: professional_accounting, #q:282, acc: 0.553
subject: professional_law, #q:1534, acc: 0.565
subject: professional_medicine, #q:272, acc: 0.779
subject: professional_psychology, #q:612, acc: 0.760
subject: public_relations, #q:110, acc: 0.709
subject: security_studies, #q:245, acc: 0.759
subject: sociology, #q:201, acc: 0.831
subject: us_foreign_policy, #q:100, acc: 0.910
subject: virology, #q:166, acc: 0.560
subject: world_religions, #q:171, acc: 0.807
Total latency: 67.512
Average accuracy: 0.737

더 알아보기 (Learn more)