N

Nemotron-3-Nano-Omni-30B-A3B-Reasoning-NVFP4

Multimodalpor NVIDIA·Página del modelo ↗

Modelo multimodal de razonamiento disperso de 30B parámetros de NVIDIA cuantizado en FP4, con 3B parámetros activos, para comprensión eficiente de imagen y texto.

Share:

Modelo base

nvidia/Nemotron-3-Nano-Omni-30B-A3B-Reasoning-BF16

Tarjeta del Modelo

At a Glance
Total parameters 31B (Mamba2-Transformer hybrid MoE)
Active parameters ~3B per token
Max context 256k tokens
Modalities (in) Video, Audio, Image, Text
Modality (out) Text
Reasoning mode On by default; toggle via enable_thinking
Best for Video+speech analysis, document intelligence (OCR/charts/long docs), GUI/agentic workflows, ASR
Minimum GPU (BF16) 1× H100 80GB (single-GPU); 1× B200 / 1× H200 recommended
Minimum GPU (FP8) 1× L40S 48GB; 1× RTX Pro 6000 / 1× B200 recommended
Minimum GPU (NVFP4) 1× RTX 5090 32GB; 1× DGX Spark / 1× Jetson Thor also supported
Precisions BF16 (62 GB) · FP8 (33 GB) · NVFP4 (21 GB)

Quick Start Guide

Model Parameters

Mode temperature top_p top_k max_tokens reasoning_budget grace_period
Thinking mode 0.6 0.95 — 20480 16384 1024
Instruct mode 0.2 — 1 1024 — —

Model Overview

Description:

NVIDIA Nemotron 3 Nano Omni is a multimodal large language model that unifies video, audio, image, and text understanding to support enterprise-grade Q&A, summarization, transcription, and document intelligence workflows. It extends the Nemotron Nano family with integrated video+speech comprehension, Graphical User Interface (GUI), Optical Character Recognition (OCR), and speech transcription capabilities, enabling end-to-end processing of rich enterprise content such as meeting recordings, M&E assets, training videos, and complex business documents. NVIDIA Nemotron 3 Nano Omni was developed by NVIDIA as part of the Nemotron model family.

This model is available for commercial use.

This model was improved using Qwen3-VL-30B-A3B-Instruct, Qwen3.5-122B-A10B, Qwen3.5-397B-A17B, Qwen2.5-VL-72B-Instruct, and gpt-oss-120b. For more information, please see the Training Dataset section below.

License/Terms of Use

Governing Terms: Use of this model is governed by the NVIDIA Open Model Agreement

Deployment Geography:

Global

Use Case:

This model is designed for enterprise customers requiring multimodal understanding capabilities. Expected users include:

  • Customer service applications (e.g., Doordash video of drop-off at a given address via OCR, drive-thru order verification)
  • Media and Entertainment (M&E) — video and speech analysis, dense captions, video search and summarization
  • Document intelligence for AI assistants (contracts, SOW/MSA, scientific discovery, financial documents)
  • GUI automation for AI agentic applications (incident management, agentic search, browser agents, email agents)

Release Date:

Build.Nvidia.com 04/28/2026 via URL

Hugging Face 04/28/2026 via:

NGC 04/28/2026 via URL

Model Architecture:

Architecture Type: Mamba2-Transformer Hybrid Mixture of Experts (MoE)

Network Architecture:

Number of model parameters: 3.1 x 10^10 (31B A3B)

Input(s):

Input Type(s): Video, Audio, Image, Text

Input Format(s):

  • Video: mp4, up to 2 minutes. For 1080p videos, sample up to 1 FPS / 128 frames. For lower-resolution videos such as 720p, higher temporal sampling such as 2 FPS / 256 frames may be used.
  • Audio: wav, mp3 files (up to 1 hour), 8kHz and higher sampling rates
  • Image: Red, Green, Blue (RGB) (jpeg, png)
  • Text: String

Input Parameters:

  • Video: Three-Dimensional (3D)
  • Audio: One-Dimensional (1D)
  • Image: Two-Dimensional (2D)
  • Text: One-Dimensional (1D)

Other Properties Related to Input:

  • Maximum context length up to 256k tokens
  • Language support: English only

Output(s)

Output Type(s): Text

Output Format(s):

  • Text: String

Output Parameters:

  • Text: One-Dimensional (1D)

Other Properties Related to Output:

  • Maximum context length up to 256k tokens.
  • Supports JSON output format
  • Supports reasoning output with chain-of-thought
  • Supports tool calling
  • Supports word-level timestamps for transcription

Our AI models are designed and/or optimized to run on NVIDIA GPU-accelerated systems. By leveraging NVIDIA's hardware (e.g. GPU cores) and software frameworks (e.g., CUDA libraries), the model achieves faster training and inference times compared to CPU-only solutions.

Software Integration:

Runtime Engine(s):

  • vLLM
  • NeMo
  • Megatron
  • NeMo-RL

Supported Hardware Microarchitecture Compatibility:

  • NVIDIA Ampere (A100 80GB SXM/NVLink)
  • NVIDIA Blackwell (B200 SXM/NVLink, RTX Pro 6000 SE, DGX Spark, Jetson Thor, RTX 5090)
  • NVIDIA Hopper (H100 SXM/NVLink, H200 SXM/NVLink)
  • NVIDIA Lovelace (L40S)

Preferred/Supported Operating System(s):

  • Linux

Inference Runtimes:

  • vLLM
  • TensorRT LLM
  • TensorRT Edge-LLM
  • llama.cpp
  • Ollama
  • SGLang

The integration of foundation and fine-tuned models into AI systems requires additional testing using use-case-specific data to ensure safe and effective deployment. Following the V-model methodology, iterative testing and validation at both unit and system levels are essential to mitigate risks, meet technical and functional requirements, and ensure compliance with safety and ethical standards before deployment.

This AI model can be embedded as an Application Programming Interface (API) call into the software environment described above.

Model Version(s):

Nemotron-3-Nano-Omni-30B-A3B-Reasoning

Download Model Weights

Precision Technical Name HuggingFace URL
BF16 Nemotron-3-Nano-Omni-30B-A3B-Reasoning-BF16 https://huggingface.co/nvidia/Nemotron-3-Nano-Omni-30B-A3B-Reasoning-BF16
FP8 Nemotron-3-Nano-Omni-30B-A3B-Reasoning-FP8 https://huggingface.co/nvidia/Nemotron-3-Nano-Omni-30B-A3B-Reasoning-FP8
NVFP4 Nemotron-3-Nano-Omni-30B-A3B-Reasoning-NVFP4 https://huggingface.co/nvidia/Nemotron-3-Nano-Omni-30B-A3B-Reasoning-NVFP4

Install the HuggingFace CLI

pip install -U "huggingface_hub[hf_xet]"
 
# Log in once; the token is cached at ~/.cache/huggingface/token
hf auth login
 
# Sanity check: should print your username and orgs
hf auth whoami

vLLM

Required version: vLLM 0.20.0 is needed. This means one of these containers:

Container

docker pull vllm/vllm-openai:v0.20.0

Audio support: Within the vLLM container, before running vllm serve, if any audio will be used (including passing use_audio_in_video: true):

python3 -m pip install "vllm[audio]"

General Invocation (1×GPU, e.g. 1×B200)

# vllm serve nvidia/Nemotron-3-Nano-Omni-30B-A3B-Reasoning-BF16 \
# vllm serve nvidia/Nemotron-3-Nano-Omni-30B-A3B-Reasoning-FP8 \
vllm serve nvidia/Nemotron-3-Nano-Omni-30B-A3B-Reasoning-NVFP4 \
  --host 0.0.0.0 \
  --max-model-len 131072 \
  --tensor-parallel-size 1 \
  --trust-remote-code \
  --video-pruning-rate 0.5 \
  --max-num-seqs 384 \
  --allowed-local-media-path / \
  --media-io-kwargs '{"video": {"fps": 2, "num_frames": 256}}' \
  --reasoning-parser nemotron_v3 \
  --enable-auto-tool-choice \
  --tool-call-parser qwen3_coder \
  --kv-cache-dtype fp8 # Omit this for BF16

Efficient Video Sampling: video-pruning-rate=0.5 drops 50% of redundant video tokens; halves video-prefill VRAM/TTFT.

Platform-Specific Notes

RTX Pro: Due to a current bug with FlashInfer + RTX Pro, append: --moe-backend triton

vLLM on DGX Spark (aarch64 / ARM64)

For everything not covered here (API examples, reasoning mode, video tuning), follow the general instructions.

1. Pull the container image

Use the upstream multi-arch vLLM v0.20.0 docker image. Docker will automatically pull the arm64 variant.

docker pull vllm/vllm-openai:v0.20.0
2. Launch the vLLM server on Spark 
WEIGHTS=/path/to/nemotron-3-nano-omni-weights

# The image does not include audio packages so we need to install them with "pip install vllm[audio]" as done in the command below
docker run --rm -it \
  --gpus all \
  --ipc=host -p 8000:8000 \
  --shm-size=16g \
  --name vllm-nemotron-omni \
  -v "${WEIGHTS}:/model:ro" \
  --entrypoint /bin/bash \
  vllm/vllm-openai:v0.20.0 -c  \
  "pip install vllm[audio] && vllm serve /model \
  --served-model-name=nemotron_3_nano_omni \
  --max-num-seqs 8 \
  --max-model-len 131072 \
  --port 8000 \
  --trust-remote-code \
  --gpu-memory-utilization 0.8 \
  --limit-mm-per-prompt '{\"video\": 1, \"image\": 1, \"audio\": 1}' \
  --media-io-kwargs '{\"video\": {\"fps\": 2,  \"num_frames\": 256}}' \
  --allowed-local-media-path=/ \
  --enable-prefix-caching \
  --max-num-batched-tokens 32768 \
  --reasoning-parser nemotron_v3 \
  --enable-auto-tool-choice \
  --tool-call-parser qwen3_coder"

In another terminal, verify the server is ready:

curl -sS http://localhost:8000/v1/models | python3 -m json.tool
Key Spark-Specific Flags
Flag Purpose Spark Guidance
--gpus all Select GPU Spark has one GB10 GPU; all is equivalent to device=0
--max-model-len Max context window Start at 131072; reduce if you hit OOM (see Memory Tuning below)
Memory Tuning on Spark

Spark uses unified LPDDR5X memory (~128 GB shared between CPU and GPU), not separate system + VRAM pools. Two levers, in order of impact:

  1. Lower --gpu-memory-utilization from 0.85 → 0.70 to free ~19 GB back to the OS and re-enable weight prefetch. Cost: smaller KV cache budget.
  2. Lower --max-model-len to reduce KV cache allocation (e.g. halving context window halves KV cache at --max-num-seqs=1). Combined override:
  --gpu-memory-utilization=0.70 \
  --max-model-len=32768 \

TensorRT-LLM

This model can also be deployed with TensorRT-LLM - see relevant instructions here.

Platform-Specific Notes

TensorRT Edge-LLM

This model can also be deployed with TensorRT Edge-LLM on NVIDIA Jetson Thor - see the Jetson AI Lab model page and the TensorRT Edge-LLM Quick Start Guide.

SGLang

The BF16 variant of this model is supported on SGLang, with the following images:

librosa must be installed first: pip install librosa --break-system-packages

To serve: sglang serve --model-path nvidia/Nemotron-3-Nano-Omni-30B-A3B-Reasoning-BF16 --trust-remote-code

[!NOTE] NVFP4 and FP8 support to come.

Platform-Specific Notes

SGLang on DGX Spark (aarch64 / ARM64)

For everything not covered here (API examples, reasoning mode, video tuning), follow the general instructions.

1. Pull the container image

Use the upstream multi-arch CUDA 13.0 docker image linked above. Docker will automatically pull the arm64 variant.

docker pull lmsysorg/sglang:dev-cu13-nemotronh-nano-omni-reasoning-v3
2. Launch the SGLang server on Spark 
WEIGHTS=/path/to/nemotron-3-nano-omni-weights

# The image does not include audio packages so we need to install them with "pip install librosa" as done in the command below
docker run --gpus all -it --rm \
  -p 30000:30000 \
  -v "${WEIGHTS}:/model:ro" \
  --shm-size 16g \
  lmsysorg/sglang:dev-cu13-nemotronh-nano-omni-reasoning-v3 \
  bash -c "pip install librosa && python3 -m sglang.launch_server --model-path /model \
  --host 0.0.0.0 \
  --port 30000 \
  --trust-remote-code \
  --mem-fraction-static 0.8 \
  --max-running-requests 8 \
  --tool-call-parser qwen3_coder \
  --reasoning-parser nemotron_3"

In another terminal, verify the server is ready:

curl -sS http://localhost:30000/v1/models | python3 -m json.tool
Key Spark-Specific Flags
Flag Purpose Spark Guidance
--gpus all Select GPU Spark has one GB10 GPU; all is equivalent to device=0
--context-length Max context window Start with default; reduce if you hit OOM (see Memory Tuning below)
Memory Tuning on Spark

Spark uses unified LPDDR5X memory (~128 GB shared between CPU and GPU), not separate system + VRAM pools. Two levers, in order of impact:

  1. Lower --mem-fraction-static from 0.80 → 0.70 to free ~13 GB back to the OS and re-enable weight prefetch. Cost: smaller KV cache budget.
  2. Lower --context-length to reduce KV cache allocation (e.g. halving context window halves KV cache at --max-running-requests=1). Combined override:
  --mem-fraction-static=0.70 \
  --context-length=32768 \

API Client (OpenAI-compatible)

from openai import OpenAI
client = OpenAI(base_url="http://localhost:8000/v1", api_key="")
MODEL = "nvidia/Nemotron-3-Nano-Omni-30B-A3B-Reasoning-NVFP4"

Image Example

import base64
 
def image_to_data_url(path: str) -> str:
    with open(path, "rb") as f:
        b64 = base64.b64encode(f.read()).decode("utf-8")
    return f"data:image/jpeg;base64,{b64}"
 
image_url = image_to_data_url("media/example1a.jpeg")
 
response = client.chat.completions.create(
    model=MODEL,
    messages=[
        {
            "role": "user",
            "content": [
                {"type": "text", "text": "Describe this image in detail."},
                {"type": "image_url", "image_url": {"url": image_url}},
            ],
        }
    ],
    max_tokens=1024,
    temperature=0.2,
    extra_body={"top_k": 1, "chat_template_kwargs": {"enable_thinking": False}},
)
print(response.choices[0].message.content)

Audio Example

from pathlib import Path
 
audio_url = Path("media/2414-165385-0000.wav").resolve().as_uri()
 
response = client.chat.completions.create(
    model=MODEL,
    messages=[
        {
            "role": "user",
            "content": [
                {"type": "audio_url", "audio_url": {"url": audio_url}},
                {"type": "text", "text": "Transcribe this audio."},
            ],
        }
    ],
    max_tokens=1024,
    temperature=0.2,
    extra_body={"top_k": 1, "chat_template_kwargs": {"enable_thinking": False}},
)
print(response.choices[0].message.content)

Video Example

from pathlib import Path
 
video_url = Path("media/demo.mp4").resolve().as_uri()
reasoning_budget = 16384
grace_period = 1024
 
response = client.chat.completions.create(
    model=MODEL,
    messages=[
        {
            "role": "user",
            "content": [
                {"type": "video_url", "video_url": {"url": video_url}},
                {"type": "text", "text": "Describe this video."},
            ],
        }
    ],
    max_tokens=20480,
    temperature=0.6,
    top_p=0.95,
    extra_body={
        "thinking_token_budget": reasoning_budget + grace_period,
        "chat_template_kwargs": {
            "enable_thinking": True,
            "reasoning_budget": reasoning_budget,
        },
        "mm_processor_kwargs": {"use_audio_in_video": False},
    },
)
print(response.choices[0].message.content)

Text Example (curl)

curl -sS http://localhost:8000/v1/chat/completions \
  -H "Content-Type: application/json" \
  -d '{"model":"nvidia/Nemotron-3-Nano-Omni-30B-A3B-Reasoning-NVFP4","messages":[{"role":"user","content":"Hello, what can you do?"}],"temperature":0.2,"top_k":1}' \
  | python3 -c "import sys,json; print(json.load(sys.stdin)['choices'][0]['message']['content'])"

PDF Example (page-by-page via Python)

The API accepts images, not raw PDF files. The script below renders each page to PNG and sends it as base64. Save as pdf_vlm_chat.py and install dependencies: pip install pymupdf pillow requests.

pdf_vlm_chat.py (click to expand)
#!/usr/bin/env python3
"""Send PDF page(s) as images to a vLLM /v1/chat/completions endpoint."""
from __future__ import annotations
 
import argparse, base64, sys
from io import BytesIO
from pathlib import Path
 
import requests
 
try:
    import fitz
    from PIL import Image
except ImportError:
    print("Install: pip install pymupdf pillow requests", file=sys.stderr)
    sys.exit(1)
 
USER_PROMPT = (
    "Summarize this PDF page: main topic, section headings, important facts "
    "or bullets, and a brief note on each figure or table. "
    "Do not invent text you cannot read."
)
API_URL = "http://localhost:8000/v1/chat/completions"
MODEL = "nvidia/Nemotron-3-Nano-Omni-30B-A3B-Reasoning-NVFP4"
MAX_TOKENS = 32000
DPI = 150
 
 
def page_to_b64(pdf_path: str, idx: int) -> str:
    doc = fitz.open(pdf_path)
    z = DPI / 72.0
    pix = doc.load_page(idx).get_pixmap(matrix=fitz.Matrix(z, z))
    img = Image.frombytes("RGB", [pix.width, pix.height], pix.samples)
    doc.close()
    buf = BytesIO()
    img.save(buf, format="PNG")
    return base64.b64encode(buf.getvalue()).decode("ascii")
 
 
def chat(url, model, b64, text, max_tokens):
    r = requests.post(url, json={
        "model": model,
        "messages": [{"role": "user", "content": [
            {"type": "text", "text": text},
            {"type": "image_url", "image_url": {"url": f"data:image/png;base64,{b64}"}},
        ]}],
        "max_tokens": max_tokens,
        "stream": False,
        "temperature": 0.2,
        "chat_template_kwargs": {"enable_thinking": False},
    }, timeout=120)
    r.raise_for_status()
    return r.json()["choices"][0]["message"]["content"]
 
 
def main():
    p = argparse.ArgumentParser()
    p.add_argument("pdf")
    p.add_argument("--page", type=int, default=0)
    p.add_argument("--all-pages", action="store_true")
    p.add_argument("-o", "--output")
    p.add_argument("--url", default=API_URL)
    p.add_argument("--model", default=MODEL)
    p.add_argument("--max-tokens", type=int, default=MAX_TOKENS)
    a = p.parse_args()
 
    doc = fitz.open(a.pdf); n = len(doc); doc.close()
    pages = range(n) if a.all_pages else [a.page]
    parts = [f"# Extracted: {Path(a.pdf).name}\n\n*Pages: {n}*\n"] if a.all_pages else []
 
    for i in pages:
        print(f"Page {i+1}/{n} ...", file=sys.stderr)
        b64 = page_to_b64(a.pdf, i)
        text = chat(a.url, a.model, b64, f"Page {i+1}.\n\n{USER_PROMPT}", a.max_tokens)
        parts.append(f"\n---\n\n## Page {i+1}\n\n{text.strip()}\n" if a.all_pages else text.strip())
 
    out = "\n".join(parts)
    if a.output:
        Path(a.output).write_text(out + "\n", encoding="utf-8")
    else:
        print(out)
 
if __name__ == "__main__":
    main()

Single page:

python3 pdf_vlm_chat.py /path/to/your_document.pdf --page 0

All pages to markdown:

python3 pdf_vlm_chat.py /path/to/your_document.pdf --all-pages -o extracted.md

Edit USER_PROMPT in the script for different tasks (detailed extraction, table parsing, etc.).

Reasoning Mode (enable_thinking)

Setting Behavior
Default (omitted) Reasoning is on. The model emits chain-of-thought before the final answer, visible in content.
"chat_template_kwargs": {"enable_thinking": false} Reasoning is off. Only the final answer appears in content.

To disable reasoning on a request, add to the JSON body:

"chat_template_kwargs": {"enable_thinking": false}

In the Python heredoc pattern, use False (Python boolean), not false (invalid Python).

We recommend thinking mode for tasks that involve reasoning and complex understanding. For video, audio, and omni use cases, try both enabling and disabling thinking for best results.

Advanced: Budget-Controlled Reasoning
from typing import Any, Dict, List

from openai import OpenAI
from transformers import AutoTokenizer


class ThinkingBudgetClient:
    def __init__(self, base_url: str, api_key: str, tokenizer_name_or_path: str):
        self.tokenizer = AutoTokenizer.from_pretrained(
            tokenizer_name_or_path, trust_remote_code=True
        )
        self.client = OpenAI(base_url=base_url, api_key=api_key)

    def chat_completion(
        self,
        model: str,
        messages: List[Dict[str, Any]],
        reasoning_budget: int = 512,
        max_tokens: int = 1024,
        **kwargs,
    ) -> Dict[str, Any]:
        assert max_tokens > reasoning_budget, (
            f"reasoning_budget must be less than max_tokens. "
            f"Got {max_tokens=} and {reasoning_budget=}"
        )

        # Step 1: generate only the reasoning trace up to the requested budget.
        response = self.client.chat.completions.create(
            model=model,
            messages=messages,
            max_tokens=reasoning_budget,
            extra_body={
                "top_k": 1,
                "chat_template_kwargs": {
                    "enable_thinking": True,
                },
            },
            **kwargs,
        )
        reasoning_content = response.choices[0].message.content or ""
        if "</think>" not in reasoning_content:
            print("No </think> found in reasoning content")
            reasoning_content = f"{reasoning_content}</think>\n\n"

        reasoning_tokens_len = len(
            self.tokenizer.encode(reasoning_content, add_special_tokens=False)
        )
        remaining_tokens = max_tokens - reasoning_tokens_len
        assert remaining_tokens > 0, (
            f"No tokens remaining for response ({remaining_tokens=}). "
            "Increase max_tokens or lower reasoning_budget."
        )

        # Step 2: continue from the closed reasoning trace and ask for the final answer.
        continued_messages = messages + [
            {"role": "assistant", "content": reasoning_content}
        ]
        prompt = self.tokenizer.apply_chat_template(
            continued_messages,
            tokenize=False,
            continue_final_message=True,
        )
        response = self.client.completions.create(
            model=model,
            prompt=prompt,
            max_tokens=remaining_tokens,
            extra_body={"top_k": 1},
            **kwargs,
        )

        return {
            "reasoning_content": reasoning_content.strip(),
            "content": response.choices[0].text,
            "finish_reason": response.choices[0].finish_reason,
        }

Video Tuning

Frame sampling (--media-io-kwargs)

Without explicit settings, vLLM may default to ~32 frames per video regardless of length. Always set --media-io-kwargs at server launch (already included in the General Invocation above):

--media-io-kwargs '{"video": {"fps": 2, "num_frames": 256}}'

Recommended num_frames ranges (at fps=2):

GPU memory Recommended num_frames range
80 GB (A100/H100) 128–512
≤40 GB 64–256

Higher values improve temporal coverage but increase VRAM and prefill time. Start at the low end of the range and increase as your workload and latency budget allow.

Notes

  1. Reasoning default: Reasoning is on by default. If you omit chat_template_kwargs, the model will produce chain-of-thought traces in content. This is appropriate for text and image inputs.
  2. Video frame sampling: The default (~32 frames) is too conservative for most real videos. Set --media-io-kwargs at server launch.
  3. PDF input format: The API does not accept raw PDF uploads. Render pages to PNG and send as base64 (see PDF Example above).
  4. max_tokens vs --max-model-len: max_tokens in the request caps only the completion (generated output). It cannot exceed the server's --max-model-len, which is the hard ceiling for prompt + completion combined. Increase the server flag if you need longer outputs.

Jetson Deployment

For Jetson deployments, vLLM, SGLang, Ollama, llama.cpp, and TensorRT Edge-LLM are supported inference frameworks; see the Jetson AI Lab model page for more details.

TensorRT Edge-LLM support is only for Jetson Thor; TensorRT-LLM is not supported on Jetson.

Training, Testing, and Evaluation Datasets:

Dataset Overview

Total Size: 354,587,705 data points (~717.0B tokens)
Total Number of Datasets: 1395 dataset entries

Dataset partition: Training [100%], Testing [N/A — evaluation benchmarks used separately], Validation [N/A — evaluation benchmarks used separately]
Time period for training data collection: 2019–2025
Time period for testing data collection: N/A (standard public benchmarks)
Time period for validation data collection: N/A (standard public benchmarks)

Dataset Description

Nemotron-Omni extends our commitment from text to multimodal, delivering the same level of openness across text, audio, image, and video.

Adapter and encoder training scale: ~127B tokens across mixed modalities spanning text+image, text+video, text+audio, and text+video+audio—reflecting real-world, contextualized interactions versus single-modality data.

Post-training for real-world tasks: ~124M curated examples across multimodal combinations (text+audio, text+image, text+video, and text+video+audio), structured to support document reasoning, computer use, and long-horizon workflows.

RL environments for agent training: 20 RL datasets across 25 environments covering 5 new multimodal tasks—visual grounding, chart and document understanding, vision-critical STEM problems, video understanding, and automatic speech recognition—extending Nemotron's RL pipeline beyond text into vision and audio.

Modality Breakdown:

Modality Dataset Entries Samples Est. Tokens (M)
text+audio 220 259,178,821 143,533.1
text+image 750 70,143,901 180,347.1
text+video 241 15,837,673 239,631.5
text+video+audio 155 8,720,044 152,499.2
text 12 707,187 958.4
Total 1395 354,587,705 716,969.2

Training data for Nemotron-Omni was assembled from a diverse collection of audio, image, video, and text datasets. Raw datasets were first converted into a standardized JSONL format with unified conversation-turn structure. Audio data was resampled to 16 kHz where needed. Image and video datasets were paired with question-answer annotations, often regenerated or refined using large vision-language models to improve quality and consistency. Quality filtering was applied using model-based judges to remove low-quality, unsafe, or off-topic samples. Deduplication and CSAM scanning were performed across all image datasets. Data was then packed into fixed-length sequences (32k, 128k, or 256k tokens) for efficient training.

Multiple safety measures were implemented throughout the data pipeline. All image/text datasets underwent CSAM (Child Sexual Abuse Material) scanning, with results tracked per dataset. Content safety filtering was applied using two independent safety judge models to flag and remove samples containing harmful content including weapons references, criminal planning, sexual content involving minors, harassment, hate speech, profanity, threats, violence, or suicide-related content. Synthetic data generation pipelines included explicit quality and safety filtering stages. Identity-fix processing was applied to correct potential biases in generated responses. The multi-stage pipeline (original → cleaned → clean+safe

Autor
N
NVIDIA
Organización · ✓
nvidia
Detalles
Descargas1.1M
Me gusta141
AccesoCódigo Abierto
Tareaany-to-any
Parámetros18.3B
Licenciaother
Libreríatransformers
Creado24 abr 2026
Actualizado5 may 2026
Ver en Hugging Face
Entiende todo el contexto.

Regístrate para leer casos de estudio completos, acceder a métricas detalladas y recibir todos los reportes.