feat: upload TurboQuant-MLX-3bit (card-twin of RotorQuant)

.gitattributes

@@ -33,3 +33,4 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+tokenizer.json filter=lfs diff=lfs merge=lfs -text

LICENSE

@@ -0,0 +1,126 @@
+NVIDIA Open Model License Agreement
+This NVIDIA Open Model License Agreement (the “Agreement”) is a legal agreement between the Legal Entity You represent, or if no
+entity is identified, You and NVIDIA Corporation and its Affiliates (“NVIDIA”) and governs Your use of the Models that NVIDIA
+provides to You under this Agreement. NVIDIA and You are each a “party” and collectively the “parties.”
+NVIDIA models released under this Agreement are intended to be used permissively and enable the further development of AI
+technologies. Subject to the terms of this Agreement, NVIDIA confirms that:
+•
+
+Models are commercially useable.
+
+•
+
+You are free to create and distribute Derivative Models.
+
+•
+
+NVIDIA does not claim ownership to any outputs generated using the Models or Model Derivatives.
+
+By using, reproducing, modifying, distributing, performing or displaying any portion or element of the Model or Derivative Model, or
+otherwise accepting the terms of this Agreement, you agree to be bound by this Agreement.
+1.
+
+Definitions. The following definitions apply to this Agreement:
+
+1.1.
+
+“Derivative Model” means all (a) modifications to the Model, (b) works based on the Model, and (c) any other derivative
+works of the Model. An output is not a Derivative Model.
+
+1.2.
+
+“Legal Entity” means the union of the acting entity and all other entities that control, are controlled by, or are under common
+control with that entity. For the purposes of this definition, “control” means (a) the power, direct or indirect, to cause the
+direction or management of such entity, whether by contract or otherwise, or (b) ownership of fifty percent (50%) or more
+of the outstanding shares, or (c) beneficial ownership of such entity.
+
+1.3.
+
+“Model” means the machine learning model, software, checkpoints, learnt weights, algorithms, parameters, configuration
+files and documentation shared under this Agreement.
+
+1.4.
+
+“You” or “Your” means an individual or Legal Entity exercising permissions granted by this Agreement.
+
+2.
+
+Conditions for Use, License Grant, AI Ethics and IP Ownership.
+
+2.1.
+Conditions for Use. The Model and any Derivative Model are subject to additional terms as described in Section 2 and
+Section 3 of this Agreement and govern Your use. If You institute copyright or patent litigation against any entity (including a crossclaim or counterclaim in a lawsuit) alleging that the Model or a Derivative Model constitutes direct or contributory copyright or
+patent infringement, then any licenses granted to You under this Agreement for that Model or Derivative Model will terminate as of
+the date such litigation is filed. NVIDIA may update this Agreement to comply with legal and regulatory requirements at any time
+and You agree to either comply with any updated license or cease Your copying, use, and distribution of the Model and any
+Derivative Model.
+2.2.
+License Grant. The rights granted herein are explicitly conditioned on Your full compliance with the terms of this
+Agreement. Subject to the terms and conditions of this Agreement, NVIDIA hereby grants to You a perpetual, worldwide, nonexclusive, no-charge, royalty-free, revocable (as stated in Section 2.1) license to publicly perform, publicly display, reproduce, use,
+create derivative works of, make, have made, sell, offer for sale, distribute (through multiple tiers of distribution) and import the
+Model.
+2.3.
+AI Ethics. NVIDIA is committed to safety, trust and transparency in AI development. NVIDIA encourages You to (a) ensure
+that the product or service You develop, use, offer as a service or distributes meets the legal and ethical requirements of the
+relevant industry or use case, (b) take reasonable measures to address unintended bias and to mitigate harm to others, including
+underrepresented or vulnerable groups, and (c) inform users of the nature and limitations of the product or service. NVIDIA
+expressly prohibits the use of its products or services for any purpose in violation of applicable law or regulation, including but not
+limited to (a) illegal surveillance, (b) illegal collection or processing of biometric information without the consent of the subject
+where required under applicable law, or (c) illegal harassment, abuse, threatening or bullying of individuals or groups of individuals
+or intentionally misleading or deceiving others.
+2.4.
+NVIDIA owns the Model and any Model Derivatives created by NVIDIA. Subject to NVIDIA’s underlying ownership rights in
+the Model or its Model Derivatives, You are and will be the owner of Your Model Derivatives. NVIDIA claims no ownership rights in
+outputs. You are responsible for outputs and their subsequent uses. Except as expressly granted in this Agreement, (a) NVIDIA
+reserves all rights, interests and remedies in connection with the Model and (b) no other license or right is granted to you by
+implication, estoppel or otherwise.
+3.
+Redistribution. You may reproduce and distribute copies of the Model or Derivative Models thereof in any medium, with or
+without modifications, provided that You meet the following conditions:
+
+3.1.
+If you distribute the Model, You must give any other recipients of the Model a copy of this Agreement and include the
+following attribution notice within a “Notice” text file with such copies: “Licensed by NVIDIA Corporation under the NVIDIA Open
+Model License”; and
+3.2.
+You may add Your own copyright statement to Your modifications and may provide additional or different license terms
+and conditions for use, reproduction, or distribution of Your modifications, or for any such Derivative Models as a whole, provided
+Your use, reproduction, and distribution of the Model otherwise complies with the conditions stated in this Agreement.
+4.
+Trademarks. This Agreement does not grant permission to use the trade names, trademarks, service marks, or product
+names of NVIDIA, except as required for reasonable and customary use in describing the origin of the Model and reproducing the
+content of the “Notice” text file.
+5.
+Disclaimer of Warranty. Unless required by applicable law or agreed to in writing, NVIDIA provides the Model on an “AS
+IS” BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied, including, without limitation, any
+warranties or conditions of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A PARTICULAR PURPOSE. You are
+solely responsible for determining the appropriateness of using or redistributing the Model, Derivative Models and outputs and
+assume any risks associated with Your exercise of permissions under this Agreement.
+6.
+Limitation of Liability. In no event and under no legal theory, whether in tort (including negligence), contract, or
+otherwise, unless required by applicable law (such as deliberate and grossly negligent acts) or agreed to in writing, will NVIDIA be
+liable to You for damages, including any direct, indirect, special, incidental, or consequential damages of any character arising as a
+result of this Agreement or out of the use or inability to use the Model, Derivative Models or outputs (including but not limited to
+damages for loss of goodwill, work stoppage, computer failure or malfunction, or any and all other commercial damages or
+losses), even if NVIDIA has been advised of the possibility of such damages.
+7.
+Indemnity. You will indemnify and hold harmless NVIDIA from and against any claim by any third party arising out of or
+related to your use or distribution of the Model, Model Derivatives or outputs.
+8.
+You.
+
+Feedback. NVIDIA appreciates your feedback, and You agree that NVIDIA may use it without restriction or compensation to
+
+9.
+Governing Law. This Agreement will be governed in all respects by the laws of the United States and the laws of the State
+of Delaware, without regard to conflict of laws principles or the United Nations Convention on Contracts for the International Sale of
+Goods. The state and federal courts residing in Santa Clara County, California will have exclusive jurisdiction over any dispute or
+claim arising out of or related to this Agreement, and the parties irrevocably consent to personal jurisdiction and venue in those
+courts; except that, either party may apply for injunctive remedies or an equivalent type of urgent legal relief in any jurisdiction.
+10.
+Trade and Compliance. You agree to comply with all applicable export, import, trade and economic sanctions laws and
+regulations, as amended, including without limitation U.S. Export Administration Regulations and Office of Foreign Assets Control
+regulations. These laws include restrictions on destinations, end-users and end-use.
+Version Release Date: June 14, 2024
+
+

README.md

@@ -0,0 +1,53 @@
+---
+license: other
+license_name: nvidia-open-model-license
+license_link: https://developer.download.nvidia.com/licenses/nvidia-open-model-license-agreement-june-2024.pdf
+base_model: nvidia/Nemotron-3-Nano-Omni-30B-A3B-Reasoning-BF16
+tags: [nemotron, multimodal, mamba2, moe, quantized, turboquant, mlx]
+---
+
+# Nemotron-3-Nano-Omni-30B-A3B-Reasoning - TurboQuant MLX 3-bit
+
+MLX 3-bit quantization of the **text tower** of `Nemotron-3-Nano-Omni-30B-A3B-Reasoning` (`nvidia/Nemotron-3-Nano-Omni-30B-A3B-Reasoning-BF16`)
+with TurboQuant weight method. Apple Silicon native via `mlx-lm`.
+
+This variant covers the LLM backbone only. Vision (CRADIO v4-H) + audio (Parakeet-TDT-0.6B-v2)
+encoders are NOT included — MLX-VLM Nemotron-Omni model class is **pending upstream support**
+(no PR observed as of 2026-05-04). For multimodal inference, use the GGUF variants with
+`llama-mtmd-cli` instead.
+
+For the matched-KV stack — TurboQuant weights + TurboQuant KV-cache modifier —
+see [`majentik/Nemotron-3-Nano-Omni-30B-A3B-Reasoning-TurboQuant-MLX-3bit-TQ-KV`](https://huggingface.co/majentik/Nemotron-3-Nano-Omni-30B-A3B-Reasoning-TurboQuant-MLX-3bit-TQ-KV).
+For the runtime KV-cache modifier itself, see
+[`majentik/Nemotron-3-Nano-Omni-30B-A3B-Reasoning-TurboQuant`](https://huggingface.co/majentik/Nemotron-3-Nano-Omni-30B-A3B-Reasoning-TurboQuant).
+
+## Modality matrix
+
+| Modality | Encoder | Quantization in this variant |
+|---|---|---|
+| Text | LLM backbone (Mamba-2 + Transformer hybrid Sparse MoE) | per the variant suffix |
+| Image | CRADIO v4-H | **BF16** (kept full-precision in every non-GGUF variant; GGUF uses mmproj-F16 split file) |
+| Audio | Parakeet-TDT-0.6B-v2 | **BF16** (same rationale) |
+| Video | Parakeet-TDT-0.6B-v2 + frame sampler | **BF16** (≤ 2 min, 256 frames @ 2 FPS) |
+
+NVIDIA's official FP8 / NVFP4 recipe keeps both encoders + the cross-modal
+MLP projectors in BF16 to preserve multimodal accuracy. We follow that
+convention in every quantized variant we ship.
+
+## Runtime quirks
+
+### MLX-LM (text-only)
+
+This variant covers the LLM backbone only. Vision + audio encoders
+are NOT included — MLX-VLM Nemotron-Omni model class is
+**pending upstream support** (no PR observed as of 2026-05-04).
+
+Use the `mlx_lm.generate` API; `enable_thinking` is a runtime flag
+(see below).
+
+### Reasoning mode
+
+`enable_thinking` defaults to `True`. To disable extended reasoning
+(e.g., for latency-sensitive cases), pass `enable_thinking=False`
+to the chat template / generate call. No separate "no-think"
+variant card exists — this is a runtime flag, not a model variant.

audio_model.py

@@ -0,0 +1,174 @@
+# Copyright (c) 2025, NVIDIA CORPORATION.  All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""Sound/Audio model components for multimodal integration.
+
+This module provides the SoundEncoder (wrapping Parakeet from HuggingFace transformers)
+and SoundProjection (MLP to project audio embeddings to LLM hidden size).
+
+The Parakeet model in HuggingFace transformers is documented at:
+https://huggingface.co/docs/transformers/en/model_doc/parakeet
+"""
+
+from typing import Optional
+
+import torch
+import torch.nn as nn
+
+from transformers import ParakeetEncoder, ParakeetEncoderConfig
+from transformers.utils import logging
+
+logger = logging.get_logger(__name__)
+
+
+class SquaredReLU(nn.Module):
+    """Squared ReLU activation function."""
+    def forward(self, x):
+        return torch.pow(torch.nn.functional.relu(x), 2)
+
+
+class RMSNorm(nn.Module):
+    def __init__(self, hidden_size, eps=1e-5):
+        super().__init__()
+        self.weight = nn.Parameter(torch.ones(hidden_size))
+        self.eps = eps
+
+    def forward(self, hidden_states):
+        input_dtype = hidden_states.dtype
+        hidden_states = hidden_states.to(torch.float32)
+        variance = hidden_states.pow(2).mean(-1, keepdim=True)
+        hidden_states = hidden_states * torch.rsqrt(variance + self.eps)
+        return (self.weight.to(torch.float32) * hidden_states).to(input_dtype)
+
+
+class SoundProjection(nn.Module):
+    """MLP projection from sound encoder hidden size to LLM hidden size.
+    
+    Architecture: RMSNorm -> linear1 -> SquaredReLU -> linear2
+    
+    This matches the Megatron checkpoint conversion structure:
+    - sound_projection.norm.weight
+    - sound_projection.linear1.weight
+    - sound_projection.linear2.weight
+    - sound_projection.linear1.bias (optional)
+    - sound_projection.linear2.bias (optional)
+    """
+    
+    def __init__(
+        self,
+        sound_hidden_size: int,
+        projection_hidden_size: int,
+        llm_hidden_size: int,
+        bias: bool = True,
+        eps: float = 1e-5,
+    ):
+        super().__init__()
+        self.norm = RMSNorm(sound_hidden_size, eps=eps)
+        self.linear1 = nn.Linear(sound_hidden_size, projection_hidden_size, bias=bias)
+        self.activation = SquaredReLU()
+        self.linear2 = nn.Linear(projection_hidden_size, llm_hidden_size, bias=bias)
+        
+    def forward(self, hidden_states: torch.Tensor) -> torch.Tensor:
+        """Project sound embeddings to LLM embedding space.
+        
+        Args:
+            hidden_states: Sound encoder output [batch, seq_len, sound_hidden_size]
+        
+        Returns:
+            Projected embeddings [batch, seq_len, llm_hidden_size]
+        """
+        hidden_states = self.norm(hidden_states)
+        hidden_states = self.linear1(hidden_states)
+        hidden_states = self.activation(hidden_states)
+        hidden_states = self.linear2(hidden_states)
+        return hidden_states
+
+
+class SoundEncoder(nn.Module):
+    """Wrapper around the Parakeet encoder from HuggingFace transformers.
+    
+    The Parakeet model is an ASR model with a Fast Conformer encoder.
+    We use only the encoder portion to extract audio embeddings.
+    
+    Checkpoint structure:
+    - sound_encoder.encoder.feature_extractor.* -> Feature extraction (mel spectrogram)
+    - sound_encoder.encoder.pre_encode.* -> Pre-encoding convolutions
+    - sound_encoder.encoder.layers.* -> Conformer layers
+    
+    Reference: https://huggingface.co/docs/transformers/en/model_doc/parakeet
+    """
+    
+    def __init__(self, config=None):
+        super().__init__()
+        
+        if config is not None:
+            # Build from config - handle both dict and config object
+            if hasattr(config, '__dict__'):
+                # It's a config object, extract relevant params for ParakeetConfig
+                config_dict = {
+                    'attention_bias': getattr(config, 'attention_bias', False),
+                    'hidden_size': getattr(config, 'hidden_size', 1024),
+                    'num_attention_heads': getattr(config, 'num_attention_heads', 8),
+                    'num_hidden_layers': getattr(config, 'num_hidden_layers', 24),
+                    'intermediate_size': getattr(config, 'intermediate_size', 4096),
+                    'conv_kernel_size': getattr(config, 'conv_kernel_size', 31),
+                    'convolution_bias': getattr(config, 'convolution_bias', False),
+                    'feat_in': getattr(config, 'feat_in', 80),
+                    'subsampling_factor': getattr(config, 'subsampling_factor', 8),
+                    'subsampling_conv_channels': getattr(config, 'subsampling_conv_channels', 256),
+                    'subsampling_conv_kernel_size': getattr(config, 'subsampling_conv_kernel_size', 3),
+                    'subsampling_conv_stride': getattr(config, 'subsampling_conv_stride', 2),
+                    'num_mel_bins': getattr(config, 'num_mel_bins', 128),
+                    'scale_input': getattr(config, 'scale_input', False),
+                }
+            elif isinstance(config, dict):
+                config_dict = config
+            else:
+                config_dict = {}
+            
+            # Create ParakeetConfig with the extracted parameters
+            parakeet_config = ParakeetEncoderConfig(**config_dict)
+            self.config = parakeet_config
+            self.encoder = ParakeetEncoder(parakeet_config)
+        else:
+            raise ValueError(
+                "config must be provided, "
+                "and ParakeetEncoder must be available in transformers."
+            )
+    
+    def forward(
+        self,
+        input_features: torch.Tensor,
+        attention_mask: Optional[torch.Tensor] = None,
+    ) -> torch.Tensor:
+        """Encode audio features.
+        
+        Args:
+            input_features: Mel spectrogram features [batch, seq_len, feature_dim]
+            attention_mask: Optional attention mask [batch, seq_len]
+            
+        Returns:
+            Audio embeddings [batch, encoded_seq_len, hidden_size]
+        """
+        outputs = self.encoder(
+            input_features=input_features,
+            attention_mask=attention_mask,
+        )
+        # Return the last hidden state
+        return outputs.last_hidden_state
+    
+    @property
+    def hidden_size(self) -> int:
+        """Return the hidden size of the encoder."""
+        return self.config.hidden_size

chat_template.jinja

@@ -0,0 +1,273 @@
+{% macro render_extra_keys(json_dict, handled_keys) %}
+    {%- if json_dict is mapping %}
+        {%- for json_key in json_dict if json_key not in handled_keys %}
+            {%- if json_dict[json_key] is mapping or (json_dict[json_key] is sequence and json_dict[json_key] is not string) %}
+                {{- '\n<' ~ json_key ~ '>' ~ (json_dict[json_key] | tojson | safe) ~ '</' ~ json_key ~ '>' }}
+            {%- else %}
+                {{- '\n<' ~ json_key ~ '>' ~ (json_dict[json_key] | string) ~ '</' ~ json_key ~ '>' }}
+            {%- endif %}
+        {%- endfor %}
+    {%- endif %}
+{%- endmacro -%}
+{%- set enable_thinking = enable_thinking if enable_thinking is defined else True %}
+{%- set reasoning_budget = reasoning_budget if reasoning_budget is defined else None %}
+{%- set truncate_history_thinking = truncate_history_thinking if truncate_history_thinking is defined else True %}
+
+{#- Scan messages for VLM thinking toggles to override enable_thinking -#}
+{%- set toggle = namespace(enable=enable_thinking) %}
+{%- for m in messages %}
+    {%- if m['role'] == 'user' or m['role'] == 'system' -%}
+        {%- if m['content'] is string -%}
+            {%- set c = m['content'] %}
+            {%- if '/think' in c.replace('</think>', '') -%}
+                {%- set toggle.enable = true -%}
+            {%- elif '/no_think' in c -%}
+                {%- set toggle.enable = false -%}
+            {%- endif -%}
+        {%- else -%}
+            {%- for part in m['content'] -%}
+                {%- if part['type'] == 'text' -%}
+                    {%- set c = part['text'] %}
+                    {%- if '/think' in c.replace('</think>', '') -%}
+                        {%- set toggle.enable = true -%}
+                    {%- elif '/no_think' in c -%}
+                        {%- set toggle.enable = false -%}
+                    {%- endif -%}
+                {%- endif -%}
+            {%- endfor -%}
+        {%- endif -%}
+    {%- endif -%}
+{%- endfor -%}
+{#- Prepare message iteration similar to LM template -#}
+{%- set ns = namespace(last_user_idx = -1) %}
+{%- set loop_messages = messages %}
+{%- for m in loop_messages %}
+    {%- if m["role"] == "user" %}
+        {%- set ns.last_user_idx = loop.index0 %}
+    {%- endif %}
+{%- endfor -%}
+
+{%- if messages[0]["role"] == "system" %}
+    {%- set system_message = messages[0]["content"] %}
+    {%- set loop_messages = messages[1:] %}
+{%- else %}
+    {%- set system_message = "" %}
+    {%- set loop_messages = messages %}
+{%- endif %}
+{%- if not tools is defined %}
+    {%- set tools = [] %}
+{%- endif %}
+{#- Recompute last_user_idx relative to loop_messages after handling system -#}
+{%- set ns = namespace(last_user_idx = -1) %}
+{%- for m in loop_messages %}
+    {%- if m["role"] == "user" %}
+        {%- set ns.last_user_idx = loop.index0 %}
+    {%- endif %}
+{%- endfor -%}
+{#- System preamble with LM formatting, sanitize thinking toggles -#}
+{%- if system_message is defined %}
+    {%- set sys_content = system_message | string %}
+    {%- set sys_content = sys_content.replace('</think>', '<_end_think>').replace('/think', '').replace('/no_think', '').replace('<_end_think>', '</think>') %}
+    {{- "<|im_start|>system\n" + sys_content }}
+{%- else %}
+    {%- if tools is iterable and tools | length > 0 %}
+        {{- "<|im_start|>system\n" }}
+    {%- endif %}
+{%- endif %}
+{%- if tools is iterable and tools | length > 0 %}
+    {%- if system_message is defined and system_message | length > 0 %}
+        {{- "\n\n" }}
+    {%- endif %}
+    {{- "# Tools\n\nYou have access to the following functions:\n\n" }}
+    {{- "<tools>" }}
+    {%- for tool in tools %}
+        {%- if tool.function is defined %}
+            {%- set tool = tool.function %}
+        {%- endif %}
+        {{- "\n<function>\n<name>" ~ tool.name ~ "</name>" }}
+        {%- if tool.description is defined %}
+            {{- '\n<description>' ~ (tool.description | trim) ~ '</description>' }}
+        {%- endif %}
+        {{- '\n<parameters>' }}
+        {%- if tool.parameters is defined and tool.parameters is mapping and tool.parameters.properties is defined and tool.parameters.properties is mapping %}
+            {%- for param_name, param_fields in tool.parameters.properties|items %}
+                {{- '\n<parameter>' }}
+                {{- '\n<name>' ~ param_name ~ '</name>' }}
+                {%- if param_fields.type is defined %}
+                    {{- '\n<type>' ~ (param_fields.type | string) ~ '</type>' }}
+                {%- endif %}
+                {%- if param_fields.description is defined %}
+                    {{- '\n<description>' ~ (param_fields.description | trim) ~ '</description>' }}
+                {%- endif %}
+                {%- if param_fields.enum is defined %}
+                    {{- '\n<enum>' ~ (param_fields.enum | tojson | safe) ~ '</enum>' }}
+                {%- endif %}
+                {%- set handled_keys = ['name', 'type', 'description', 'enum'] %}
+                {{- render_extra_keys(param_fields, handled_keys) }}
+                {{- '\n</parameter>' }}
+            {%- endfor %}
+        {%- endif %}
+        {%- set handled_keys = ['type', 'properties', 'required'] %}
+        {{- render_extra_keys(tool.parameters, handled_keys) }}
+        {%- if tool.parameters is defined and tool.parameters.required is defined %}
+            {{- '\n<required>' ~ (tool.parameters.required | tojson | safe) ~ '</required>' }}
+        {%- endif %}
+        {{- '\n</parameters>' }}
+        {%- set handled_keys = ['type', 'name', 'description', 'parameters'] %}
+        {{- render_extra_keys(tool, handled_keys) }}
+        {{- '\n</function>' }}
+    {%- endfor %}
+    {{- "\n</tools>" }}
+
+    {{- '\n\nIf you choose to call a function ONLY reply in the following format with NO suffix:\n\n<tool_call>\n<function=example_function_name>\n<parameter=example_parameter_1>\nvalue_1\n</parameter>\n<parameter=example_parameter_2>\nThis is the value for the second parameter\nthat can span\nmultiple lines\n</parameter>\n</function>\n</tool_call>\n\n<IMPORTANT>\nReminder:\n- Function calls MUST follow the specified format: an inner <function=...></function> block must be nested within <tool_call></tool_call> XML tags\n- Required parameters MUST be specified\n- You may provide optional reasoning for your function call in natural language BEFORE the function call, but NOT after\n- If there is no function call available, answer the question like normal with your current knowledge and do not tell the user about function calls\n</IMPORTANT>' }}
+{%- endif -%}
+{%- if system_message is defined %}
+    {{- '<|im_end|>\n' }}
+{%- else %}
+    {%- if tools is iterable and tools | length > 0 %}
+        {{- '<|im_end|>\n' }}
+    {%- endif %}
+{%- endif -%}
+{#- Iterate conversation -#}
+{%- for message in loop_messages %}
+    {%- if message.role == "assistant" %}
+        {#- Use LM assistant handling -#}
+        {%- if message.reasoning_content is defined and message.reasoning_content is string and message.reasoning_content | trim | length > 0 %}
+            {%- set content = "<think>\n" ~ message.reasoning_content ~ "\n</think>\n" ~ (message.content | default('', true)) %}
+        {%- else %}
+            {%- set content = message.content | default('', true) %}
+            {%- if content is string -%}
+                {%- if '<think>' not in content and '</think>' not in content -%}
+                    {%- set content = "<think></think>" ~ content -%}
+                {%- endif -%}
+            {%- else -%}
+                {%- set content = content -%}
+            {%- endif -%}
+        {%- endif %}
+        {%- if message.tool_calls is defined and message.tool_calls is iterable and message.tool_calls | length > 0 %}
+            {{- '<|im_start|>assistant\n' }}
+                {%- set include_content = not (truncate_history_thinking and loop.index0 < ns.last_user_idx) %}
+                {%- if content is string and content | trim | length > 0 %}
+                    {%- if include_content %}
+                        {{- (content | trim) ~ '\n' -}}
+                    {%- else %}
+                        {%- set c = (content | string) %}
+                        {%- if '</think>' in c %}
+                            {%- set c = c.split('</think>')[-1] %}
+                        {%- elif '<think>' in c %}
+                            {%- set c = c.split('<think>')[0] %}
+                        {%- endif %}
+                        {%- set c = "<think></think>" ~ c | trim %}
+                        {%- if c | length > 0 %}
+                            {{- c ~ '\n' -}}
+                        {%- endif %}
+                    {%- endif %}
+                {%- else %}
+                    {{- "<think></think>" -}}
+                {%- endif %}
+                {%- for tool_call in message.tool_calls %}
+                    {%- if tool_call.function is defined %}
+                        {%- set tool_call = tool_call.function %}
+                    {%- endif %}
+                    {{- '<tool_call>\n<function=' ~ tool_call.name ~ '>\n' -}}
+                        {%- if tool_call.arguments is defined %}
+                            {%- for args_name, args_value in tool_call.arguments|items %}
+                                {{- '<parameter=' ~ args_name ~ '>\n' -}}
+                                    {%- set args_value = args_value | tojson | safe if args_value is mapping or (args_value is sequence and args_value is not string) else args_value | string %}
+                                {{- args_value ~ '\n</parameter>\n' -}}
+                            {%- endfor %}
+                        {%- endif %}
+                    {{- '</function>\n</tool_call>\n' -}}
+                {%- endfor %}
+                {{- '<|im_end|>\n' }}
+        {%- else %}
+            {%- if not (truncate_history_thinking and loop.index0 < ns.last_user_idx) %}
+                {{- '<|im_start|>assistant\n' ~ (content | default('', true) | string | trim) ~ '<|im_end|>\n' }}
+            {%- else %}
+                {%- set c = (content | default('', true) | string) %}
+                {%- if '<think>' in c and '</think>' in c %}
+                    {%- set c = "<think></think>" ~ c.split('</think>')[-1] %}
+                {%- endif %}
+                {%- set c = c | trim %}
+                {%- if c | length > 0 %}
+                    {{- '<|im_start|>assistant\n' ~ c ~ '<|im_end|>\n' }}
+                {%- else %}
+                    {{- '<|im_start|>assistant\n<|im_end|>\n' }}
+                {%- endif %}
+            {%- endif %}
+        {%- endif %}
+    {%- elif message.role == "user" or message.role == "system" %}
+        {{- '<|im_start|>' + message.role + '\n' }}
+        {#- Build VLM multimodal content when content is a sequence -#}
+        {%- if message.content is string -%}
+            {%- set content = (message.content | string) %}
+        {%- else -%}
+            {%- set text_ns = namespace(val='') -%}
+            {%- set mm_content = '' -%}
+            {%- set counters = namespace(images=0, videos=0, audios=0) -%}
+            {%- for part in message['content'] -%}
+                {%- if part['type'] == 'image' or part['type'] == 'image_url' -%}
+                    {%- set counters.images = counters.images + 1 -%}
+                {%- elif part['type'] == 'video' or part['type'] == 'video_url' -%}
+                    {%- set counters.videos = counters.videos + 1 -%}
+                {%- elif part['type'] == 'audio' or part['type'] == 'audio_url' -%}
+                    {%- set counters.audios = counters.audios + 1 -%}
+                {%- elif part['type'] == 'text' -%}
+                    {%- set text_ns.val = text_ns.val + part['text'] -%}
+                {%- endif -%}
+            {%- endfor -%}
+            {%- if '<image>' in text_ns.val -%}
+                {%- set counters.images = 0 -%}
+            {%- endif -%}
+            {%- if '<video>' in text_ns.val -%}
+                {%- set counters.videos = 0 -%}
+            {%- endif -%}
+            {%- if '<so_embedding>' in text_ns.val -%}
+                {%- set counters.audios = 0 -%}
+            {%- endif -%}
+            {%- if counters.images > 1 -%}
+                {%- set image_tags = namespace(tags=[]) -%}
+                {%- for i in range(counters.images) -%}
+                    {%- set image_tags.tags = image_tags.tags + ['<image ' + (i + 1)|string + '><image>'] -%}
+                {%- endfor -%}
+                {%- set mm_content = ' '.join(image_tags.tags) + '\n' -%}
+            {%- elif counters.images == 1 -%}
+                {%- set mm_content = '<image>\n' -%}
+            {%- endif -%}
+            {%- set mm_content = mm_content + '<video>\n' * counters.videos -%}
+            {%- set mm_content = mm_content + '<so_embedding>\n' * counters.audios -%}
+            {%- set content = mm_content + text_ns.val.lstrip('\n') -%}
+        {%- endif -%}
+        {#- Sanitize thinking toggle directives from user/system content -#}
+        {%- set content = content.replace('</think>', '<_end_think>').replace('/think', '').replace('/no_think', '').replace('<_end_think>', '</think>') -%}
+        {%- set content = content | trim -%}
+        {%- if message.role == "user" and loop.index0 == ns.last_user_idx and reasoning_budget is not none -%}
+            {{- content + '\n\n{thinking token budget: ' + (reasoning_budget | string) + '}' -}}
+        {%- else -%}
+            {{- content -}}
+        {%- endif -%}
+        {{- '<|im_end|>\n' }}
+    {%- elif message.role == "tool" %}
+        {%- if loop.previtem and loop.previtem.role != "tool" %}
+            {{- '<|im_start|>user\n' }}
+        {%- endif %}
+        {{- '<tool_response>\n' }}
+        {{- message.content }}
+        {{- '\n</tool_response>\n' }}
+        {%- if not loop.last and loop.nextitem.role != "tool" %}
+            {{- '<|im_end|>\n' }}
+        {%- elif loop.last %}
+            {{- '<|im_end|>\n' }}
+        {%- endif %}
+    {%- else %}
+        {{- '<|im_start|>' + message.role + '\n' + message.content + '<|im_end|>\n' }}
+    {%- endif %}
+{%- endfor -%}
+{#- Generation prompt using computed thinking toggle -#}
+{%- if add_generation_prompt %}
+    {%- if toggle.enable %}
+        {{- '<|im_start|>assistant\n<think>\n' }}
+    {%- else %}
+        {{- '<|im_start|>assistant\n<think></think>' }}
+    {%- endif %}
+{%- endif %}

config.json

@@ -0,0 +1,371 @@
+{
+  "architectures": [
+    "NemotronH_Nano_Omni_Reasoning_V3"
+  ],
+  "auto_map": {
+    "AutoConfig": "configuration.NemotronH_Nano_Omni_Reasoning_V3_Config",
+    "AutoModel": "modeling.NemotronH_Nano_Omni_Reasoning_V3",
+    "AutoModelForCausalLM": "modeling.NemotronH_Nano_Omni_Reasoning_V3"
+  },
+  "max_sequence_length": 131072,
+  "downsample_ratio": 0.5,
+  "force_image_size": 512,
+  "patch_size": 16,
+  "use_thumbnail": true,
+  "eos_token_id": 11,
+  "model_type": "NemotronH_Nano_Omni_Reasoning_V3",
+  "ps_version": "v2",
+  "template": "n5h_5p5_nanov2",
+  "torch_dtype": "bfloat16",
+  "image_tag_type": "internvl",
+  "img_context_token_id": 18,
+  "video_context_token_id": 131081,
+  "img_context_token": "<image>",
+  "video_context_token": "<video>",
+  "img_start_token": "<img>",
+  "img_end_token": "</img>",
+  "vit_hidden_size": 1280,
+  "projector_hidden_size": 20480,
+  "norm_mean": [
+    0.48145466,
+    0.4578275,
+    0.40821073
+  ],
+  "norm_std": [
+    0.26862954,
+    0.26130258,
+    0.27577711
+  ],
+  "video_pruning_rate": 0.7,
+  "sound_context_token_id": 27,
+  "sound_context_token": "<so_embedding>",
+  "sound_config": {
+    "model_type": "parakeet",
+    "hidden_size": 1024,
+    "num_attention_heads": 8,
+    "num_hidden_layers": 24,
+    "intermediate_size": 4096,
+    "conv_kernel_size": 9,
+    "convolution_bias": false,
+    "subsampling_conv_channels": 256,
+    "subsampling_conv_kernel_size": 3,
+    "subsampling_conv_stride": 2,
+    "subsampling_factor": 8,
+    "num_mel_bins": 128,
+    "projection_hidden_size": 4096,
+    "projection_bias": false,
+    "sampling_rate": 16000
+  },
+  "llm_config": {
+    "architectures": [
+      "NemotronHForCausalLM"
+    ],
+    "auto_map": {
+      "AutoConfig": "configuration_nemotron_h.NemotronHConfig",
+      "AutoModelForCausalLM": "modeling_nemotron_h.NemotronHForCausalLM"
+    },
+    "model_type": "nemotron_h",
+    "bos_token_id": 1,
+    "chunk_size": 128,
+    "conv_kernel": 4,
+    "expand": 2,
+    "eos_token_id": 11,
+    "pad_token_id": 0,
+    "torch_dtype": "bfloat16",
+    "transformers_version": "4.55.4",
+    "attention_bias": false,
+    "attention_dropout": 0.0,
+    "head_dim": 128,
+    "hidden_dropout": 0.0,
+    "hidden_size": 2688,
+    "hybrid_override_pattern": "MEMEM*EMEMEM*EMEMEM*EMEMEM*EMEMEM*EMEMEMEM*EMEMEMEME",
+    "initializer_range": 0.02,
+    "intermediate_size": 1856,
+    "layer_norm_epsilon": 1e-05,
+    "mamba_head_dim": 64,
+    "mamba_hidden_act": "silu",
+    "mamba_num_heads": 64,
+    "mamba_proj_bias": false,
+    "max_position_embeddings": 262144,
+    "mlp_bias": false,
+    "mlp_hidden_act": "relu2",
+    "moe_intermediate_size": 1856,
+    "moe_shared_expert_intermediate_size": 3712,
+    "n_group": 1,
+    "n_groups": 8,
+    "n_routed_experts": 128,
+    "n_shared_experts": 1,
+    "norm_eps": 1e-05,
+    "norm_topk_prob": true,
+    "num_attention_heads": 32,
+    "num_experts_per_tok": 6,
+    "num_hidden_layers": 52,
+    "num_key_value_heads": 2,
+    "num_logits_to_keep": 1,
+    "partial_rotary_factor": 1.0,
+    "rescale_prenorm_residual": true,
+    "residual_in_fp32": false,
+    "rope_theta": 10000,
+    "routed_scaling_factor": 2.5,
+    "sliding_window": null,
+    "ssm_state_size": 128,
+    "tie_word_embeddings": false,
+    "time_step_floor": 0.0001,
+    "time_step_limit": [
+      0.0,
+      1e+30
+    ],
+    "time_step_max": 0.1,
+    "time_step_min": 0.001,
+    "topk_group": 1,
+    "use_bias": false,
+    "use_cache": true,
+    "use_conv_bias": true,
+    "use_mamba_kernels": true,
+    "vocab_size": 131072
+  },
+  "vision_config": {
+    "auto_map": {
+      "AutoConfig": "nvidia/C-RADIOv2-H--hf_model.RADIOConfig",
+      "AutoModel": "nvidia/C-RADIOv2-H--hf_model.RADIOModel"
+    },
+    "adaptor_configs": {},
+    "adaptor_names": null,
+    "architectures": [
+      "RADIOModel"
+    ],
+    "args": {
+      "aa": null,
+      "amp": true,
+      "amp_dtype": "bfloat16",
+      "amp_impl": "native",
+      "aug_repeats": 0,
+      "aug_splits": 0,
+      "bn_eps": null,
+      "bn_momentum": null,
+      "cache_dir": null,
+      "channels_last": false,
+      "checkpoint_hist": 10,
+      "chk_keep_forever": 100,
+      "class_map": "",
+      "clip_grad": null,
+      "clip_mode": "norm",
+      "cls_token_per_teacher": true,
+      "coco_annotations_file": "/datasets/coco2017-adlsa/annotations/captions_val2017.json",
+      "coco_image_dir": "/datasets/coco2017-adlsa/val2017",
+      "color_jitter": 0.4,
+      "cooldown_epochs": 0,
+      "cpe_max_size": 2048,
+      "crd_loss": false,
+      "crd_loss_weight": 0.8,
+      "crop_pct": null,
+      "cutmix": 0.0,
+      "cutmix_minmax": null,
+      "dataset_download": false,
+      "debug_full_knn": false,
+      "decay_epochs": 90,
+      "decay_milestones": [
+        90,
+        180,
+        270
+      ],
+      "decay_rate": 0.1,
+      "depchain": true,
+      "dist_bn": "reduce",
+      "dist_norm_weight": 0.0,
+      "distributed": true,
+      "drop": 0.0,
+      "drop_block": null,
+      "drop_connect": null,
+      "drop_path": null,
+      "dtype": "bfloat16",
+      "epoch_repeats": 0.0,
+      "eval": false,
+      "eval_metric": "knn_top1",
+      "eval_teacher": false,
+      "eval_teacher_only": false,
+      "eval_throughput": false,
+      "fast_norm": false,
+      "fd_loss_fn": "MSE",
+      "feature_normalization": "SHIP_NORM",
+      "feature_summarizer": "cls_token",
+      "feature_upscale_factor": null,
+      "force_new_wandb_id": false,
+      "force_spectral_reparam": true,
+      "freeze_bn": false,
+      "fsdp": false,
+      "fuser": "",
+      "gp": null,
+      "grad_accum_steps": 1,
+      "grad_checkpointing": false,
+      "head_init_bias": null,
+      "head_init_scale": null,
+      "head_warmup": 5,
+      "head_weight_decay": 0.001,
+      "hflip": 0.5,
+      "img_size": null,
+      "in_chans": null,
+      "initial_checkpoint": null,
+      "input_size": null,
+      "interpolation": "",
+      "layer_decay": null,
+      "local_rank": 0,
+      "log_interval": 50,
+      "log_mlflow": false,
+      "log_wandb": true,
+      "loss_auto_balance": false,
+      "lr_base": 0.1,
+      "lr_base_scale": "",
+      "lr_base_size": 256,
+      "lr_cycle_decay": 0.5,
+      "lr_cycle_limit": 1,
+      "lr_cycle_mul": 1.0,
+      "lr_k_decay": 1.0,
+      "lr_noise": null,
+      "lr_noise_pct": 0.67,
+      "lr_noise_std": 1.0,
+      "mean": null,
+      "mesa": false,
+      "min_lr": 0,
+      "mixup": 0.0,
+      "mixup_mode": "batch",
+      "mixup_off_epoch": 0,
+      "mixup_prob": 1.0,
+      "mixup_switch_prob": 0.5,
+      "mlp_hidden_size": 1520,
+      "mlp_num_inner": 3,
+      "mlp_version": "v2",
+      "model": "vit_huge_patch16_224",
+      "model_kwargs": {},
+      "model_norm": false,
+      "momentum": 0.9,
+      "no_aug": false,
+      "no_ddp_bb": true,
+      "no_prefetcher": false,
+      "no_resume_opt": false,
+      "num_classes": null,
+      "opt_betas": null,
+      "opt_eps": null,
+      "patience_epochs": 10,
+      "pin_mem": false,
+      "prefetcher": true,
+      "pretrained": false,
+      "rank": 0,
+      "ratio": [
+        0.75,
+        1.3333333333333333
+      ],
+      "recount": 1,
+      "recovery_interval": 0,
+      "register_multiple": 10,
+      "remode": "pixel",
+      "reprob": 0.0,
+      "reset_loss_state": false,
+      "resplit": false,
+      "save_images": false,
+      "scale": [
+        0.5,
+        1.0
+      ],
+      "sched": "cosine",
+      "seed": 42,
+      "smoothing": 0.1,
+      "spectral_heads": false,
+      "spectral_reparam": false,
+      "split_bn": false,
+      "start_epoch": null,
+      "std": null,
+      "stream_teachers": true,
+      "sync_bn": false,
+      "synchronize_step": false,
+      "teachers": [
+        {
+          "fd_normalize": false,
+          "feature_distillation": true,
+          "input_size": 378,
+          "model": "ViT-H-14-378-quickgelu",
+          "name": "clip",
+          "pretrained": "dfn5b",
+          "type": "open_clip",
+          "use_summary": true
+        },
+        {
+          "fd_normalize": false,
+          "feature_distillation": true,
+          "input_size": 378,
+          "model": "ViT-SO400M-14-SigLIP-384",
+          "name": "siglip",
+          "pretrained": "webli",
+          "type": "open_clip",
+          "use_summary": true
+        },
+        {
+          "fd_normalize": false,
+          "feature_distillation": true,
+          "input_size": 378,
+          "model": "dinov2_vitg14_reg",
+          "name": "dino_v2",
+          "type": "dino_v2",
+          "use_summary": true
+        },
+        {
+          "fd_normalize": false,
+          "feature_distillation": true,
+          "input_size": 1024,
+          "model": "vit-h",
+          "name": "sam",
+          "type": "sam",
+          "use_summary": false
+        }
+      ],
+      "torchcompile": null,
+      "torchscript": false,
+      "train_interpolation": "random",
+      "train_split": "train",
+      "tta": 0,
+      "use_coco": false,
+      "use_multi_epochs_loader": false,
+      "val_ema_only": false,
+      "val_split": "val",
+      "vflip": 0.0,
+      "vitdet_version": 1,
+      "wandb_entity": "",
+      "wandb_job_type": "",
+      "wandb_name": "",
+      "wandb_project": "",
+      "warmup_lr": 1e-05,
+      "warmup_prefix": false,
+      "worker_seeding": "all",
+      "workers": 8,
+      "world_size": 256,
+      "min_num_patches": 1024,
+      "max_num_patches": 13312
+    },
+    "feature_normalizer_config": null,
+    "inter_feature_normalizer_config": null,
+    "max_resolution": 2048,
+    "patch_size": 16,
+    "preferred_resolution": [
+      768,
+      768
+    ],
+    "torch_dtype": "bfloat16",
+    "version": "radio_v2.5-h",
+    "vitdet_window_size": null,
+    "min_num_patches": 1024,
+    "max_num_patches": 13312,
+    "video_target_num_patches": 1024,
+    "video_maintain_aspect_ratio": true,
+    "video_temporal_patch_size": 2,
+    "video_prompt_version": 2,
+    "separate_video_embedder": true
+  },
+  "quantization": {
+    "group_size": 64,
+    "bits": 3
+  },
+  "quantization_config": {
+    "group_size": 64,
+    "bits": 3
+  }
+}

configuration.py

@@ -0,0 +1,123 @@
+# Copyright (c) 2025, NVIDIA CORPORATION.  All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+from transformers.configuration_utils import PretrainedConfig
+from transformers.utils import logging
+from .configuration_nemotron_h import NemotronHConfig
+from .configuration_radio import RADIOConfig
+
+logger = logging.get_logger(__name__)
+
+
+class SoundConfig(PretrainedConfig):
+    """Configuration for the sound/audio model (Parakeet encoder + projection)."""
+    model_type = "parakeet"
+    
+    def __init__(
+        self,
+        # Parakeet encoder config
+        hidden_size: int = 1024,
+        num_attention_heads: int = 8,
+        num_hidden_layers: int = 24,
+        intermediate_size: int = 4096,
+        conv_kernel_size: int = 31,
+        feat_in: int = 80,  # Mel features
+        subsampling_factor: int = 8,
+        # Projection config  
+        projection_hidden_size: int = 20480,
+        projection_bias: bool = True,
+        # Audio processing
+        sampling_rate: int = 16000,
+        **kwargs,
+    ):
+        super().__init__(**kwargs)
+        self.hidden_size = hidden_size
+        self.num_attention_heads = num_attention_heads
+        self.num_hidden_layers = num_hidden_layers
+        self.intermediate_size = intermediate_size
+        self.conv_kernel_size = conv_kernel_size
+        self.feat_in = feat_in
+        self.subsampling_factor = subsampling_factor
+        self.projection_hidden_size = projection_hidden_size
+        self.projection_bias = projection_bias
+        self.sampling_rate = sampling_rate
+
+
+class NemotronH_Nano_Omni_Reasoning_V3_Config(PretrainedConfig):
+    model_type = 'NemotronH_Nano_Omni_Reasoning_V3'
+    is_composition = True
+
+    def __init__(
+        self,
+        vision_config=None,
+        llm_config=None,
+        sound_config=None,
+        force_image_size=None,
+        downsample_ratio=0.5,
+        template=None,
+        ps_version='v1',
+        image_tag_type="internvl",
+        projector_hidden_size=4096,
+        vit_hidden_size=1280,
+        attn_implementation="flash_attention_2",
+        video_pruning_rate: float = 0.0,
+        video_temporal_patch_size: int = 2,
+        # Sound/audio settings
+        sound_context_token_id: int = None,
+        sound_context_token: str = "<audio>",
+        **kwargs
+    ):
+        super().__init__(**kwargs)
+
+        if vision_config is not None:
+            self.vision_config = RADIOConfig(**vision_config)
+        else:
+            self.vision_config = RADIOConfig()
+
+        # Handle both cases: when loading from JSON (llm_config is dict) and when called internally by transformers (llm_config is None)
+        if llm_config is not None:
+            self.llm_config = NemotronHConfig(**llm_config)
+        else:
+            self.llm_config = NemotronHConfig()
+
+        # Sound/audio model configuration
+        if sound_config is not None:
+            self.sound_config = SoundConfig(**sound_config)
+        else:
+            self.sound_config = None  # Sound model is optional
+
+        # Assign configuration values
+        self.force_image_size = force_image_size
+        self.downsample_ratio = downsample_ratio
+        self.template = template  # TODO move out of here and into the tokenizer
+        self.ps_version = ps_version  # Pixel shuffle version
+        self.image_tag_type = image_tag_type # TODO: into the tokenizer too?
+        self.projector_hidden_size = projector_hidden_size
+        self.vit_hidden_size = vit_hidden_size
+        self.video_pruning_rate = video_pruning_rate
+        self.video_temporal_patch_size = video_temporal_patch_size
+        
+        # Sound/audio token settings
+        self.sound_context_token_id = sound_context_token_id
+        self.sound_context_token = sound_context_token
+
+        self._attn_implementation = attn_implementation
+        self.vision_config.use_flash_attn = self._attn_implementation is not None and "flash_attention" in self._attn_implementation
+        self.llm_config._attn_implementation = self._attn_implementation
+
+    # vLLM's `NemotronH_Nano_VL_V2` implementation reads the language-model sub-config as
+    # `config.text_config`. Our HF config stores it as `config.llm_config`; expose an alias so the
+    # same config object loads under both loaders without having to duplicate the dict on disk.
+    @property
+    def text_config(self):
+        return self.llm_config

configuration_nemotron_h.py

@@ -0,0 +1,276 @@
+# coding=utf-8
+# Copyright 2024 AI21 Labs Ltd. and the HuggingFace Inc. team. All rights reserved.
+# Copyright (c) 2025, NVIDIA CORPORATION. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+"""NemotronH model configuration"""
+
+import re
+
+from transformers.configuration_utils import PretrainedConfig
+from transformers.utils import logging
+
+
+logger = logging.get_logger(__name__)
+
+
+class NemotronHConfig(PretrainedConfig):
+    r"""
+    This is the configuration class to store the configuration of a [`NemotronHModel`]. It is used to instantiate a
+    NemotronH model according to the specified arguments, defining the model architecture. Instantiating a configuration
+    with the defaults will yield a similar configuration to that of the NemotronH-v0.1 model.
+
+    [todo](todo)
+
+    Configuration objects inherit from [`PretrainedConfig`] and can be used to control the model outputs. Read the
+    documentation from [`PretrainedConfig`] for more information.
+
+
+    Args:
+        vocab_size (`int`, *optional*, defaults to 131072):
+            Vocabulary size of the NemotronH model. Defines the number of different tokens that can be represented by the
+            `inputs_ids` passed when calling [`NemotronHModel`]
+        tie_word_embeddings (`bool`, *optional*, defaults to `False`):
+            Whether the model's input and output word embeddings should be tied. Note that this is only relevant if the
+            model has a output word embedding layer.
+        hidden_size (`int`, *optional*, defaults to 4096):
+            Dimension of the hidden representations.
+        intermediate_size (`int`, *optional*, defaults to 21504):
+            Dimension of the MLP representations.
+        num_hidden_layers (`int`, *optional*, defaults to 52):
+            Number of hidden layers in the Transformer encoder.
+        hybrid_override_pattern (`str`, *optional*, defaults to `"M-M-M-M*-M-M-M-M-M*-M-M-M-M-M*-M-M-M-M-M*-M-M-M-M-M-"`):
+            The pattern of the hybrid model. The pattern is a string of characters where each character represents M: Mamba2, *: Attention, -: MLP
+        num_attention_heads (`int`, *optional*, defaults to 32):
+            Number of attention heads for each attention layer in the Transformer encoder.
+        head_dim (`int`, *optional*, defaults to 128):
+            Dimension of each attention head.
+        num_key_value_heads (`int`, *optional*, defaults to 8):
+            This is the number of key_value heads that should be used to implement Grouped Query Attention. If
+            `num_key_value_heads=num_attention_heads`, the model will use Multi Head Attention (MHA), if
+            `num_key_value_heads=1` the model will use Multi Query Attention (MQA) otherwise GQA is used.
+        mlp_hidden_act (`str`, *optional*, defaults to "relu2"):
+            The non-linear activation function in the MLP layers.
+        attention_bias (`bool`, *optional*, defaults to `False`):
+            Whether to use bias in attention layers.
+        mlp_bias (`bool`, *optional*, defaults to `False`):
+            Whether to use bias in MLP layers.
+        use_bias (`bool`, *optional*, defaults to `False`):
+            Whether to use bias in the model.
+        initializer_range (`float`, *optional*, defaults to 0.02):
+            The standard deviation of the truncated_normal_initializer for initializing all weight matrices.
+        layer_norm_epsilon (`float`, *optional*, defaults to 1e-5):
+            The epsilon used by the layer normalization layers.
+        residual_in_fp32 (`bool`, *optional*, defaults to `False`):
+            Whether or not residuals should be in `float32`. If set to `False` residuals will keep the same `dtype` as the rest of the model.
+        use_cache (`bool`, *optional*, defaults to `True`):
+            Whether or not the model should return the last key/values attentions (not used by all models). Only
+            relevant if `config.is_decoder=True`.
+        num_logits_to_keep (`int` or `None`, *optional*, defaults to 1):
+            Number of prompt logits to calculate during generation. If `None`, all logits will be calculated. If an
+            integer value, only last `num_logits_to_keep` logits will be calculated.
+        pad_token_id (`int`, *optional*, defaults to 0):
+            The id of the padding token.
+        bos_token_id (`int`, *optional*, defaults to 1):
+            The id of the "beginning-of-sequence" token.
+        eos_token_id (`int`, *optional*, defaults to 2):
+            The id of the "end-of-sequence" token.
+        sliding_window (`int`, *optional*, defaults to None):
+            Sliding window attention window size.
+        max_position_embeddings (`int`, *optional*, defaults to 4096):
+            The maximum sequence length that this model might ever be used with.
+        attention_dropout (`float`, *optional*, defaults to 0.0):
+            The dropout ratio for the attention probabilities.
+        hidden_dropout (`float`, *optional*, defaults to 0.0):
+            The dropout ratio for the hidden states.
+        use_mamba_kernels (`bool`, *optional*, defaults to `True`):
+            Flag indicating whether or not to use the fast mamba kernels. These are available only if `mamba-ssm` and
+            `causal-conv1d` are installed, and the mamba modules are running on a CUDA device.
+        ssm_state_size (`int`, *optional*, defaults to 128):
+            The dimension of the mamba state space latents.
+        mamba_num_heads (`int`, *optional*, defaults to 128):
+            Number of heads in Mamba layers.
+        mamba_n_groups (`int`, *optional*, defaults to 8):
+            Number of groups in Mamba layers.
+        mamba_head_dim (`int`, *optional*, defaults to 64):
+            Dimension of each Mamba head.
+        mamba_d_conv (`int`, *optional*, defaults to 4):
+            The size of the mamba convolution kernel.
+        mamba_expand (`int`, *optional*, defaults to 2):
+            Expanding factor used to determine the mamba intermediate size.
+        mamba_hidden_act (`str`, *optional*, defaults to "silu"):
+            The non-linear activation function in the Mamba layers.
+        mamba_dt_min (`float`, *optional*, defaults to 0.001):
+            Minimum value for the time step in Mamba.
+        mamba_dt_max (`float`, *optional*, defaults to 0.1):
+            Maximum value for the time step in Mamba.
+        mamba_dt_limit (`tuple`, *optional*, defaults to (0.0, float("inf"))):
+            Limits for the time step in Mamba.
+        mamba_dt_init_floor (`float`, *optional*, defaults to 1e-4):
+            Floor value for time step initialization in Mamba.
+        mamba_conv_bias (`bool`, *optional*, defaults to `True`):
+            Whether to use bias in the convolution layer of the mamba mixer block.
+        mamba_proj_bias (`bool`, *optional*, defaults to `False`):
+            Whether to use bias in the input and output projections of the mamba mixer block.
+        mamba_chunk_size (`int`, *optional*, defaults to 256):
+            Size of chunks for Mamba processing.
+        rescale_prenorm_residual (`bool`, *optional*, defaults to `True`):
+            Whether to rescale the pre-normalization residual connections.
+    """
+
+    model_type = "nemotron_h"
+    keys_to_ignore_at_inference = ["past_key_values"]
+
+    def __init__(
+        self,
+        vocab_size=131072,
+        tie_word_embeddings=False,
+        hidden_size=4096,
+        intermediate_size=21504,
+        num_hidden_layers=52,
+        hybrid_override_pattern="M-M-M-M*-M-M-M-M-M*-M-M-M-M-M*-M-M-M-M-M*-M-M-M-M-M-",
+        num_attention_heads=32,
+        head_dim=128,
+        num_key_value_heads=8,  # nemo: num_query_groups
+        mlp_hidden_act="relu2",
+        attention_bias=False,
+        mlp_bias=False,
+        use_bias=False,
+        initializer_range=0.02, # nemo: init_method_std
+        layer_norm_epsilon=1e-5, # nemo: layernorm_epsilon
+        residual_in_fp32=False,  #  Megatron Core default value
+        use_cache=True,
+        num_logits_to_keep=1,
+        pad_token_id=0,
+        bos_token_id=1,
+        eos_token_id=2,
+        sliding_window=None,
+        max_position_embeddings=4096,
+        attention_dropout=0.0,
+        hidden_dropout=0.0, # * ADDED
+        use_mamba_kernels=True,
+        ssm_state_size=128, # mamba_state_size
+        mamba_num_heads=128,
+        mamba_n_groups=8,  # nemo: mamba_ssm_ngroups = num_heads
+        mamba_head_dim=64,
+        mamba_d_conv=4,
+        mamba_expand=2,
+        mamba_hidden_act="silu",
+        mamba_dt_min=0.001,
+        mamba_dt_max=0.1,
+        mamba_dt_limit=(0.0, float("inf")),
+        mamba_dt_init_floor=1e-4,
+        mamba_conv_bias=True,
+        mamba_proj_bias=False,
+        mamba_chunk_size=128,
+        rescale_prenorm_residual=True,
+        n_routed_experts=8,
+        n_shared_experts=1,
+        moe_intermediate_size=7688,
+        moe_shared_expert_intermediate_size=7688,
+        num_experts_per_tok=2,
+        routed_scaling_factor=1.0,
+        n_group=1,
+        topk_group=1,
+        norm_topk_prob=True,
+        **kwargs,
+    ):
+        self.vocab_size = vocab_size
+        self.tie_word_embeddings = tie_word_embeddings
+        self.hidden_size = hidden_size
+        self.intermediate_size = intermediate_size
+        self.num_hidden_layers = num_hidden_layers
+        self.hybrid_override_pattern = hybrid_override_pattern
+        self.num_attention_heads = num_attention_heads
+        self.head_dim = head_dim
+        self.sliding_window = sliding_window
+        self.max_position_embeddings = max_position_embeddings
+        self.attention_dropout = attention_dropout
+        self.hidden_dropout = hidden_dropout
+
+        # Validate hybrid_override_pattern
+        # M: Mamba2, *: Attention, -: MLP, E: MoE
+        assert len(self.hybrid_override_pattern) == self.num_hidden_layers, "hybrid_override_pattern must have the same length as num_hidden_layers"
+        assert re.match(r"^[*\-ME]+$", self.hybrid_override_pattern), "hybrid_override_pattern must only contain characters 'M', '*', '-', or 'E'"
+
+        # for backward compatibility
+        if num_key_value_heads is None:
+            num_key_value_heads = num_attention_heads
+
+        self.num_key_value_heads = num_key_value_heads
+        self.mlp_hidden_act = mlp_hidden_act
+        self.attention_bias = attention_bias
+        self.mlp_bias = mlp_bias
+        self.use_bias = use_bias
+        self.initializer_range = initializer_range
+        self.layer_norm_epsilon = layer_norm_epsilon
+        self.residual_in_fp32 = residual_in_fp32
+
+        self.use_cache = use_cache
+        self.num_logits_to_keep = num_logits_to_keep
+
+        self.use_mamba_kernels = use_mamba_kernels
+        self.n_groups = mamba_n_groups
+        self.mamba_head_dim = mamba_head_dim
+        self.ssm_state_size = ssm_state_size
+        self.mamba_num_heads = mamba_num_heads
+        self.conv_kernel = mamba_d_conv
+        self.expand = mamba_expand
+        self.mamba_hidden_act = mamba_hidden_act
+        self.time_step_min = mamba_dt_min
+        self.time_step_max = mamba_dt_max
+        self.time_step_limit = mamba_dt_limit
+        self.time_step_floor = mamba_dt_init_floor
+        self.use_conv_bias = mamba_conv_bias
+        self.mamba_proj_bias = mamba_proj_bias
+        self.chunk_size = mamba_chunk_size
+        self.rescale_prenorm_residual = rescale_prenorm_residual
+        self.n_routed_experts = n_routed_experts
+        self.n_shared_experts = n_shared_experts
+        self.moe_intermediate_size = moe_intermediate_size
+        self.moe_shared_expert_intermediate_size = moe_shared_expert_intermediate_size
+        self.num_experts_per_tok = num_experts_per_tok
+        self.routed_scaling_factor = routed_scaling_factor
+        self.n_group = n_group
+        self.topk_group = topk_group
+        self.norm_topk_prob = norm_topk_prob
+
+        # Derived per-layer block type list. Transformers 5.6+ looks this up as `layer_types` on the
+        # config to pick the correct cache structure (linear attention vs full attention). MLP (stateless)
+        # layers are tagged as "moe" here only because the transformers cache validator rejects "mlp";
+        # from the cache's point of view, both MLP and MoE layers need no kv cache (they become
+        # LinearAttentionLayer with zero state).
+        self.layer_types = [
+            "mamba" if self.hybrid_override_pattern[i] == "M" else
+            "attention" if self.hybrid_override_pattern[i] == "*" else
+            "moe" if self.hybrid_override_pattern[i] == "-" else "moe"
+            for i in range(self.num_hidden_layers)
+        ]
+        # Per-layer semantic labels used by the modeling code (includes "mlp", which the
+        # transformers `layer_types` validator would reject — that's why `layer_types` above maps
+        # "-" → "moe" for cache purposes, while this attribute keeps the true label for the block
+        # dispatch in NemotronHBlock).
+        self.layers_block_type = [
+            "mamba" if self.hybrid_override_pattern[i] == "M" else
+            "attention" if self.hybrid_override_pattern[i] == "*" else
+            "mlp" if self.hybrid_override_pattern[i] == "-" else "moe"
+            for i in range(self.num_hidden_layers)
+        ]
+
+        super().__init__(
+            pad_token_id=pad_token_id,
+            bos_token_id=bos_token_id,
+            eos_token_id=eos_token_id,
+            tie_word_embeddings=tie_word_embeddings,
+            **kwargs,
+        )

configuration_radio.py

@@ -0,0 +1,152 @@
+# Copyright (c) 2024, NVIDIA CORPORATION.  All rights reserved.
+#
+# NVIDIA CORPORATION and its licensors retain all intellectual property
+# and proprietary rights in and to this software, related documentation
+# and any modifications thereto.  Any use, reproduction, disclosure or
+# distribution of this software and related documentation without an express
+# license agreement from NVIDIA CORPORATION is strictly prohibited.
+
+from dataclasses import dataclass
+from typing import Optional, NamedTuple, Union, List, Dict
+
+from transformers import PretrainedConfig
+
+
+class Resolution(NamedTuple):
+    height: int
+    width: int
+
+
+@dataclass
+class RadioResource:
+    url: str
+    patch_size: int
+    max_resolution: int
+    preferred_resolution: Resolution
+    vitdet_num_windowed: Optional[int] = None
+    vitdet_num_global: Optional[int] = None
+
+
+RESOURCE_MAP = {
+    # RADIOv2.5
+    "radio_v2.5-b": RadioResource(
+        "https://huggingface.co/nvidia/RADIO/resolve/main/radio-v2.5-b_half.pth.tar?download=true",
+        patch_size=16,
+        max_resolution=2048,
+        preferred_resolution=(768, 768),
+        vitdet_num_global=4,
+    ),
+    "radio_v2.5-l": RadioResource(
+        "https://huggingface.co/nvidia/RADIO/resolve/main/radio-v2.5-l_half.pth.tar?download=true",
+        patch_size=16,
+        max_resolution=2048,
+        preferred_resolution=(768, 768),
+        vitdet_num_global=4,
+    ),
+    "radio_v2.5-h": RadioResource(
+        "https://huggingface.co/nvidia/RADIO/resolve/main/radio_v2.5-h.pth.tar?download=true",
+        patch_size=16,
+        max_resolution=2048,
+        preferred_resolution=(768, 768),
+        vitdet_num_global=4,
+    ),
+    "radio_v2.5-h-norm": RadioResource(
+        "https://huggingface.co/nvidia/RADIO/resolve/main/radio_v2.5-h-norm.pth.tar?download=true",
+        patch_size=16,
+        max_resolution=2048,
+        preferred_resolution=(768, 768),
+        vitdet_num_global=4,
+    ),
+    "radio_v2.5-g": RadioResource(
+        "https://huggingface.co/nvidia/RADIO/resolve/main/radio_v2.5-g.pth.tar?download=true",
+        patch_size=14,
+        max_resolution=1792,
+        preferred_resolution=(896, 896),
+        vitdet_num_global=8,
+    ),
+    # RADIO
+    "radio_v2.1": RadioResource(
+        "https://huggingface.co/nvidia/RADIO/resolve/main/radio_v2.1_bf16.pth.tar?download=true",
+        patch_size=16,
+        max_resolution=2048,
+        preferred_resolution=Resolution(432, 432),
+        vitdet_num_windowed=5,
+    ),
+    "radio_v2": RadioResource(
+        "https://huggingface.co/nvidia/RADIO/resolve/main/radio_v2.pth.tar?download=true",
+        patch_size=16,
+        max_resolution=2048,
+        preferred_resolution=Resolution(432, 432),
+        vitdet_num_windowed=5,
+    ),
+    "radio_v1": RadioResource(
+        "https://huggingface.co/nvidia/RADIO/resolve/main/radio_v1.pth.tar?download=true",
+        patch_size=14,
+        max_resolution=1050,
+        preferred_resolution=Resolution(378, 378),
+    ),
+    # E-RADIO
+    "e-radio_v2": RadioResource(
+        "https://huggingface.co/nvidia/RADIO/resolve/main/eradio_v2.pth.tar?download=true",
+        patch_size=16,
+        max_resolution=2048,
+        preferred_resolution=Resolution(512, 512),
+    ),
+    # C-RADIO
+    "c-radio_v2.5-g": RadioResource(
+        "https://huggingface.co/nvidia/C-RADIOv2-g/resolve/main/c-radio_v2-g_half.pth.tar",
+        patch_size=16,
+        max_resolution=2048,
+        preferred_resolution=(768, 768),
+        vitdet_num_global=8,
+    ),
+    "c-radio_v3-l": RadioResource(
+        # NOTE: Currently, this model cannot be loaded via TorchHub. Instead, use the transformers API at https://huggingface.co/nvidia/C-RADIOv3-L
+        # and accept the license terms.
+        "https://huggingface.co/nvidia/C-RADIOv3-L/resolve/main/c-radio-v3_l_half.pth.tar?download=true",
+        patch_size=16,
+        max_resolution=2048,
+        preferred_resolution=Resolution(512, 512),
+    ),
+}
+
+DEFAULT_VERSION = "radio_v2.5-h"
+
+
+class RADIOConfig(PretrainedConfig):
+    """Pretrained Hugging Face configuration for RADIO models."""
+
+    def __init__(
+        self,
+        args: Optional[dict] = None,
+        version: Optional[str] = DEFAULT_VERSION,
+        patch_size: Optional[int] = None,
+        max_resolution: Optional[int] = None,
+        preferred_resolution: Optional[Resolution] = None,
+        adaptor_names: Union[str, List[str]] = None,
+        adaptor_configs: Dict[str, Dict[str, int]] = None,
+        vitdet_window_size: Optional[int] = None,
+        feature_normalizer_config: Optional[dict] = None,
+        inter_feature_normalizer_config: Optional[dict] = None,
+        **kwargs,
+    ):
+        self.args = args
+        for field in ["dtype", "amp_dtype"]:
+            if self.args is not None and field in self.args:
+                # Convert to a string in order to make it serializable.
+                # For example for torch.float32 we will store "float32",
+                # for "bfloat16" we will store "bfloat16".
+                self.args[field] = str(args[field]).split(".")[-1]
+        self.version = version
+        resource = RESOURCE_MAP[version]
+        self.patch_size = patch_size or resource.patch_size
+        self.max_resolution = max_resolution or resource.max_resolution
+        self.preferred_resolution = (
+            preferred_resolution or resource.preferred_resolution
+        )
+        self.adaptor_names = adaptor_names
+        self.adaptor_configs = adaptor_configs
+        self.vitdet_window_size = vitdet_window_size
+        self.feature_normalizer_config = feature_normalizer_config
+        self.inter_feature_normalizer_config = inter_feature_normalizer_config
+        super().__init__(**kwargs)

evs.py

@@ -0,0 +1,73 @@
+import torch
+from typing import Tuple
+
+class EfficientVideoSampling:
+    @staticmethod
+    def compute_retention_mask(
+        *,
+        video_embeds: torch.FloatTensor,
+        thw: torch.LongTensor,
+        spatial_merge_size: int,
+        q: float,
+    ):
+        """
+        Computes the retention mask for video embeddings based on the grid dimensions.
+
+        Args:
+            video_embeds (`torch.FloatTensor` of shape `(T * H * W, hidden_size)`):
+                The video embeddings to compute the retention mask for.
+            thw (`torch.LongTensor` of shape `(3)`):
+                The temporal, height and width of feature shape of each video in LLM.
+            spatial_merge_size (`int`): The spatial merge size of the video embeddings.
+                If embeddings will be downsampled *later*, this should be the downsampling factor.
+            q: (`float`): Pruning rate factor, indicating number of tokens to prune (remove)
+
+        Returns:
+            `torch.Tensor`: The retention mask for the video embeddings (T * H * W).
+                1 for tokens to keep, 0 for tokens to prune.
+        """
+        T, H, W = thw
+
+        # video_embeds = einops.rearrange(
+        #     video_embeds,
+        #     "(T H W) C -> T H W C",
+        #     T=T,
+        #     H=H // spatial_merge_size,
+        #     W=W // spatial_merge_size,
+        # )
+        # Use reshape instead of einops to avoid graph breaks
+        video_embeds = video_embeds.reshape(
+            T, H // spatial_merge_size, W // spatial_merge_size, video_embeds.size(-1)
+        )
+
+        # Core EVS
+        similarity = torch.nn.functional.cosine_similarity(
+            video_embeds[1:, ...], video_embeds[:-1, ...], dim=-1
+        )
+        dissimilarity = 1 - similarity
+
+        # Always ensure we include all tokens from the first frame
+        dissimilarity = torch.cat(
+            [255 * torch.ones_like(video_embeds[:1, :, :, 0]), dissimilarity], dim=0
+        )
+        dissimilarity_flat = dissimilarity.view(-1)
+
+        min_num_tokens = (H // spatial_merge_size) * (W // spatial_merge_size)  # a single frame
+        evs_num_tokens = int(T * min_num_tokens * (1 - q))
+        num_tokens_to_keep = max(min_num_tokens, evs_num_tokens)
+
+        order = torch.argsort(dissimilarity_flat,
+                              dim=-1,
+                              descending=True,
+                              stable=True)
+        topk_indices = order[:num_tokens_to_keep]
+
+        retention_mask = torch.zeros_like(dissimilarity_flat, dtype=torch.bool)
+        retention_mask[topk_indices] = True
+        retention_mask = retention_mask.reshape(dissimilarity.size())
+
+        # print(
+        #     f"Computed retention mask of shape {retention_mask.shape=} with sparsity {retention_mask.float().mean().item():.4f} for {q=}",
+        # )
+        mask = retention_mask.view(-1)  # "T H W -> (T H W)"
+        return mask

generation_config.json

@@ -0,0 +1,14 @@
+{
+  "_from_model_config": true,
+  "bos_token_id": 1,
+  "eos_token_id": [2, 11],
+  "pad_token_id": 0,
+  "do_sample": true,
+  "temperature": 0.6,
+  "top_p": 0.95,
+  "max_new_tokens": 16384,
+  "reasoning_budget": 16384,
+  "reasoning_grace": 512,
+  "repetition_penalty": 1.0,
+  "transformers_version": "4.55.4"
+}

image_processing.py

@@ -0,0 +1,228 @@
+import math
+from typing import List, Optional, Union
+
+from PIL import Image
+import torch
+from transformers.image_processing_base import BatchFeature
+from transformers.image_processing_utils_fast import BaseImageProcessorFast
+from transformers.image_utils import make_list_of_images, get_image_type, ImageInput, ImageType
+from transformers.utils import TensorType
+import torchvision.transforms as T
+
+
+class NemotronH_Nano_Omni_Reasoning_V3ImageProcessor(BaseImageProcessorFast):
+    """
+    Dynamic-resolution image processor for the V3 omni model.
+
+    Each image is resized to a single tile whose patch-grid `(h_patches, w_patches)` is chosen to
+    land between `min_num_patches` and `max_num_patches` (on a 16×16-pixel grid), respecting
+    aspect ratio. This matches the algorithm in vLLM's `DynamicResolutionImageTiler`
+    (`vllm/model_executor/models/nano_nemotron_vl.py`) so HF and vLLM inference see identical pixel
+    inputs.
+    """
+
+    model_input_names = ["pixel_values"]
+
+    def __init__(
+        self,
+        norm_mean=None,
+        norm_std=None,
+        patch_size=16,
+        downsample_ratio=0.5,
+        min_num_patches=1024,
+        max_num_patches=13312,
+        max_model_len=16384,
+        video_target_num_patches=1024,
+        video_maintain_aspect_ratio=True,
+        **kwargs,
+    ):
+        super().__init__(**kwargs)
+        self.norm_mean = norm_mean
+        self.norm_std = norm_std
+        self.patch_size = patch_size
+        self.downsample_ratio = downsample_ratio
+        # Integer reduction factor for pixel_shuffle (downsample_ratio = 0.5 → factor 2).
+        self._downsample_factor = int(round(1.0 / downsample_ratio))
+        # Per-image patch-grid bounds (on the pre-pixel-shuffle 16×16 grid).
+        self.min_num_patches = min_num_patches
+        self.max_num_patches = max_num_patches
+        self.max_model_len = max_model_len
+        # Video frames use a separate (fixed) target-patch budget with aspect-ratio preserved.
+        # Matches vLLM's `_compute_aspect_preserving_size` in `nano_nemotron_vl.py`.
+        self.video_target_num_patches = video_target_num_patches
+        self.video_maintain_aspect_ratio = video_maintain_aspect_ratio
+
+    # Keep the PIL image through to `_preprocess` — we need PIL.resize (bicubic) to match vLLM's
+    # algorithm exactly; resizing a tensor via `torchvision.transforms.Resize` uses different
+    # kernels and breaks bit-exact agreement.
+    def _process_image(self, image: ImageInput, **kwargs):
+        if get_image_type(image) == ImageType.PIL:
+            if image.mode != "RGB":
+                image = image.convert("RGB")
+        return image
+
+    # transformers 5.6 renamed this hook from `_process_image` to `process_image`; alias both.
+    process_image = _process_image
+
+    # Toggled by `processing.py` around video calls (the strict `ImagesKwargs` validator won't let
+    # us thread a new kwarg down, so we use a flag on the instance instead).
+    _is_video_mode: bool = False
+
+    def _preprocess(
+        self,
+        images,
+        return_tensors: Optional[Union[str, TensorType]] = None,
+        **kwargs,
+    ) -> BatchFeature:
+        """Port of vLLM's `DynamicResolutionImageTiler._images_to_pixel_values_lst`.
+
+        When `self._is_video_mode=True` (flipped by `processing.py` before the video call), each
+        input is resized using the **video** target-size rule (`video_target_num_patches`,
+        aspect-ratio preserved) instead of the image dynamic-res rule. This matches vLLM's split
+        between `video_to_pixel_values` (video path) and `DynamicResolutionImageTiler` (image
+        path).
+        """
+        is_video = self._is_video_mode
+        images = make_list_of_images(images)
+
+        target_sizes = []
+        if is_video:
+            for img in images:
+                target_w_patches, target_h_patches = self._compute_target_patches_video(img)
+                target_sizes.append((target_w_patches, target_h_patches))
+        else:
+            # Image path: per-image budget bounded by [min_num_patches, max_num_patches], with a
+            # global cap derived from `max_model_len` × pixel-shuffle factor².
+            num_tokens_available = self.max_model_len - 4  # match vLLM's reserve
+            budget = num_tokens_available * (self._downsample_factor ** 2)
+            budget = max(budget, self.min_num_patches * len(images))
+            max_budget = self.max_num_patches if (self.max_num_patches and self.max_num_patches > 0) else float("inf")
+            per_image_budget = [max(min(budget, max_budget), self.min_num_patches) for _ in images]
+            # Single-pass — vLLM has an iterative scale-down for the batch, but it rarely binds in
+            # single-image / small-batch inference.
+            for img, tokens_for_media in zip(images, per_image_budget):
+                target_w_patches, target_h_patches = self._compute_target_patches(img, tokens_for_media)
+                target_sizes.append((target_w_patches, target_h_patches))
+
+        import numpy as np
+        norm_mean = torch.tensor(self.norm_mean).view(1, 3, 1, 1)
+        norm_std = torch.tensor(self.norm_std).view(1, 3, 1, 1)
+
+        pixel_values_list = []
+        num_tokens_per_image = []
+        imgs_sizes = []
+        for img, (wp, hp) in zip(images, target_sizes):
+            target_w = wp * self.patch_size
+            target_h = hp * self.patch_size
+            # Use torch's antialiased bicubic interpolation to match vLLM's
+            # `_bicubic_resize_and_normalize` (`torch.nn.functional.interpolate`, `antialias=True`).
+            # PIL's bicubic uses a different kernel (and no antialiasing), producing visibly different
+            # pixel values that amplify through the 52-layer ViT / mamba stack and cause HF/vLLM
+            # outputs to diverge past the first few tokens.
+            arr = np.asarray(img, dtype=np.uint8)  # (H, W, 3)
+            t = torch.from_numpy(arr).permute(2, 0, 1).unsqueeze(0).to(dtype=torch.float32)  # (1, 3, H, W)
+            if t.shape[-2] != target_h or t.shape[-1] != target_w:
+                t = torch.nn.functional.interpolate(
+                    t, size=(target_h, target_w), mode="bicubic", align_corners=False, antialias=True
+                )
+            t = (t / 255.0 - norm_mean) / norm_std
+            pixel_values_list.append(t.squeeze(0))  # (3, H, W)
+            num_tokens_per_image.append((wp * hp) // (self._downsample_factor ** 2))
+            imgs_sizes.append((target_h, target_w))
+
+        # Stack if all images have the same target size (common for same-aspect-ratio batches);
+        # otherwise keep as a list of (3, H_i, W_i) tensors. The outer model's `extract_feature`
+        # handles both.
+        all_same_shape = all(t.shape == pixel_values_list[0].shape for t in pixel_values_list)
+        if all_same_shape:
+            pixel_values = torch.stack(pixel_values_list, dim=0)
+        else:
+            pixel_values = pixel_values_list
+
+        return BatchFeature(
+            data={
+                "pixel_values": pixel_values,
+                # One tile per image in dynamic mode — `num_tokens` is what the text-side
+                # placeholder expansion should use.
+                "num_patches": [1] * len(images),
+                "num_tokens": num_tokens_per_image,
+                "imgs_sizes": imgs_sizes,
+            },
+            tensor_type=(return_tensors if all_same_shape else None),
+        )
+
+    def _compute_target_patches(self, img: Image.Image, tokens_available: int):
+        """Port of `DynamicResolutionImageTiler.process_media` (image-only, no thumbnail)."""
+        orig_w, orig_h = img.width, img.height
+        # Ceil-ish: `round(x + 0.5)` == `floor(x) + 1` for non-integer x, `x` for integer.
+        closest_patch_h = round(orig_h / self.patch_size + 0.5)
+        closest_patch_w = round(orig_w / self.patch_size + 0.5)
+        patches = closest_patch_h * closest_patch_w
+
+        # Downscale to fit the token budget.
+        factor = min(math.sqrt(tokens_available / patches), 1.0)
+        target_h = math.floor(factor * closest_patch_h)
+        target_w = math.floor(factor * closest_patch_w)
+
+        # Scale up if below the per-image minimum.
+        if (
+            tokens_available > self.min_num_patches
+            and target_h * target_w < self.min_num_patches
+        ):
+            up = math.sqrt(self.min_num_patches / (target_h * target_w))
+            target_h = math.ceil(up * target_h)
+            target_w = math.ceil(up * target_w)
+
+        # Round each dim to a multiple of the pixel_shuffle factor so tokens divide evenly.
+        divisor = self._downsample_factor
+        rem_h = target_h % divisor
+        if rem_h:
+            inc_h = divisor - rem_h
+            if (target_h + inc_h) * target_w <= tokens_available:
+                target_h += inc_h
+            else:
+                target_h = max(divisor, target_h - rem_h)
+        rem_w = target_w % divisor
+        if rem_w:
+            inc_w = divisor - rem_w
+            if target_h * (target_w + inc_w) <= tokens_available:
+                target_w += inc_w
+            else:
+                target_w = max(divisor, target_w - rem_w)
+
+        return target_w, target_h
+
+    def _compute_target_patches_video(self, img: Image.Image):
+        """Port of vLLM's `_compute_aspect_preserving_size` for video frames.
+
+        Each frame is resized to roughly `video_target_num_patches` (default 1024) on the 16×16
+        grid, with aspect ratio preserved and dims snapped to a multiple of the pixel_shuffle
+        factor. For `maintain_aspect_ratio=False`, it falls back to a square of sqrt(target)
+        patches.
+        """
+        orig_w, orig_h = img.width, img.height
+        target = self.video_target_num_patches
+        divisor = self._downsample_factor  # 2 for pixel_shuffle
+        if self.video_maintain_aspect_ratio:
+            aspect_wh = orig_w / max(orig_h, 1)
+            ph = max(round(math.sqrt(target / aspect_wh)), 1)
+            pw = max(round(math.sqrt(target * aspect_wh)), 1)
+            if divisor > 1:
+                rem_h = ph % divisor
+                rem_w = pw % divisor
+                ph_up = ph + (divisor - rem_h if rem_h else 0)
+                ph_down = ph - rem_h
+                pw_up = pw + (divisor - rem_w if rem_w else 0)
+                pw_down = pw - rem_w
+                # Prefer rounding up when the up-rounded patch count still fits the target;
+                # otherwise round down (mirrors vLLM's logic exactly).
+                if ph_up * pw_up <= target:
+                    ph, pw = ph_up, pw_up
+                else:
+                    ph = max(divisor, ph_down)
+                    pw = max(divisor, pw_down)
+        else:
+            side = int(math.sqrt(target))
+            side = max(divisor, (side // divisor) * divisor)
+            ph = pw = side
+        return pw, ph

model-00001-of-00004.safetensors

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ca94492401d9dd573e9db1bf775af6a47c4a74e0f7552e52c8bd2021cc018d3d
+size 5369191530

model-00002-of-00004.safetensors

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:7af0adc06f77169285bbd8bbc6fe02e51e55fbfe5df025626387ac81833bf180
+size 5368030759

model-00003-of-00004.safetensors

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:345727605f07bc7379365ae5f4dd0119475980c0809101a4858ab7c6c1c93cc1
+size 5369622810

model-00004-of-00004.safetensors

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:33d65b4a04f1b8a14f280f78d549eed18058a5ab9bcb02cc732ca18fb872a9e9
+size 588120685

preprocessor_config.json

@@ -0,0 +1,15 @@
+{
+  "image_processor_type": "NemotronH_Nano_Omni_Reasoning_V3ImageProcessor",
+  "auto_map": {
+    "AutoImageProcessor": "image_processing.NemotronH_Nano_Omni_Reasoning_V3ImageProcessor",
+    "AutoVideoProcessor": "video_processing.NemotronH_Nano_Omni_Reasoning_V3VideoProcessor",
+    "AutoProcessor": "processing.NemotronH_Nano_Omni_Reasoning_V3Processor"
+  },
+  "patch_size": 16,
+  "downsample_ratio": 0.5,
+  "norm_mean": [0.48145466, 0.4578275, 0.40821073],
+  "norm_std": [0.26862954, 0.26130258, 0.27577711],
+  "min_num_patches": 1024,
+  "max_num_patches": 13312,
+  "max_model_len": 16384
+}

special_tokens_map.json

@@ -0,0 +1,23 @@
+{
+  "bos_token": {
+    "content": "<s>",
+    "lstrip": false,
+    "normalized": false,
+    "rstrip": false,
+    "single_word": false
+  },
+  "eos_token": {
+    "content": "<|im_end|>",
+    "lstrip": false,
+    "normalized": false,
+    "rstrip": false,
+    "single_word": false
+  },
+  "unk_token": {
+    "content": "<unk>",
+    "lstrip": false,
+    "normalized": false,
+    "rstrip": false,
+    "single_word": false
+  }
+}

tokenizer.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e5e7dc84d72e8f248321611c3d6dce23407b135f55f8caf5b26119798d12f85f
+size 17077367