# NemotronH Omni

NemotronH Omni es un modelo de razonamiento multimodal de NVIDIA que combina el modelo de lenguaje híbrido Mamba-Transformer [NemotronH](./nemotron_h) con un codificador de visión [RADIO](./radio) y un codificador de sonido opcional basado en Parakeet. Las parches de imagen (y vídeo) se proyectan a través de una torre RADIO y un MLP de pixel-shuffle hacia el espacio de incrustaciones del modelo de lenguaje en las posiciones de tokens de contexto `<image>` / `<video>`; los fragmentos de audio se proyectan de la misma manera en las posiciones `<audio>`. El resultado es un único modelo autoregresivo que razona de forma conjunta sobre texto, imágenes, vídeo y sonido.

El siguiente ejemplo demuestra cómo razonar sobre una imagen y un prompt de texto con [AutoModelForImageTextToText](/docs/transformers/v5.23.0/es/model_doc/auto#transformers.AutoModelForImageTextToText).

```python
from transformers import AutoModelForImageTextToText, AutoProcessor

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

processor = AutoProcessor.from_pretrained(model_id)
model = AutoModelForImageTextToText.from_pretrained(
    model_id,
    device_map="auto",
    # the Parakeet audio encoder has no flash-attention kernel, so pin that tower to sdpa
    attn_implementation={"": "flash_attention_2", "audio_config": "sdpa"},
)

messages = [
    {
        "role": "user",
        "content": [
            {
                "type": "image",
                "url": "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/pipeline-cat-chonk.jpeg",
            },
            {"type": "text", "text": "Describe this image in detail."},
        ],
    }
]
inputs = processor.apply_chat_template(
    messages,
    add_generation_prompt=True,
    tokenize=True,
    return_dict=True,
    return_tensors="pt",
).to(model.device)

output = model.generate(**inputs, max_new_tokens=128, do_sample=False)
print(processor.decode(output[0, inputs["input_ids"].shape[-1] :], skip_special_tokens=True))
```

## NemotronH_Omni_Reasoning_V3_Config[[transformers.NemotronH_Omni_Reasoning_V3_Config]]

#### transformers.NemotronH_Omni_Reasoning_V3_Config[[transformers.NemotronH_Omni_Reasoning_V3_Config]]

```python
transformers.NemotronH_Omni_Reasoning_V3_Config(transformers_version: str | None = None, architectures: list[str] | None = None, output_hidden_states: bool | None = False, return_dict: bool | None = True, dtype: str | torch.dtype | None = None, chunk_size_feed_forward: int = 0, is_encoder_decoder: bool = False, id2label: dict[int, str] | dict[str, str] | None = None, label2id: dict[str, int] | dict[str, str] | None = None, problem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = None, vision_config: dict | transformers.configuration_utils.PreTrainedConfig | None = None, text_config: dict | transformers.configuration_utils.PreTrainedConfig | None = None, audio_config: dict | transformers.configuration_utils.PreTrainedConfig | None = None, force_image_size: int | None = None, downsample_ratio: float = 0.5, projector_hidden_size: int = 4096, vision_hidden_size: int = 1280, video_pruning_rate: float = 0.0, video_temporal_patch_size: int = 2, image_token_id: int | None = None, video_token_id: int | None = None, audio_token_id: int | None = None)
```

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/nemotron_h_omni/configuration_nemotron_h_omni.py#L28)

**Parámetros:**

vision_config (`dict` o `RadioConfig`, *opcional*) : Configuración para el codificador de visión de RADIO. El valor predeterminado es una [RadioConfig](/docs/transformers/v5.23.0/es/model_doc/radio#transformers.RadioConfig) predeterminada.

text_config (`dict` o `NemotronHConfig`, *opcional*) : Configuración para el modelo de lenguaje NemotronH. El valor predeterminado es una [NemotronHConfig](/docs/transformers/v5.23.0/es/model_doc/nemotron_h#transformers.NemotronHConfig) predeterminada.

audio_config (`dict` o `ParakeetEncoderConfig`, *opcional*) : Configuración para el codificador de sonido Parakeet opcional. `None` deshabilita la rama de audio.

force_image_size (`int`, *opcional*) : Resolución de imagen de entrada fija (en píxeles) que espera la torre de visión.

downsample_ratio (`float`, *opcional*, valor predeterminado 0.5) : Relación de submuestreo espacial por pixel-shuffle aplicada a las características visuales.

projector_hidden_size (`int`, *opcional*, valor predeterminado 4096) : Tamaño oculto del proyector MLP de visión a LLM.

vision_hidden_size (`int`, *opcional*, valor predeterminado 1280) : Tamaño oculto de las características visuales de RADIO.

video_pruning_rate (`float`, *opcional*, valor predeterminado 0.0) : Tasa de poda de tokens de Efficient-Video-Sampling; `0.0` desactiva la poda.

video_temporal_patch_size (`int`, *opcional*, valor predeterminado: 2) : Número de fotogramas que se agrupan en un único parche temporal por el incrustador de video.

image_token_id (`int`, *opcional*) : Id de token usado como marcador de posición de contexto de imagen en `input_ids`.

video_token_id (`int`, *opcional*) : Id del token utilizado como marcador de posición de contexto de video en `input_ids`.

audio_token_id (`int`, *opcional*) : Id de token usado como marcador de posición de contexto de audio en `input_ids`.

Esta es la clase de configuración para almacenar la configuración de un Nemotron H OmniModel. Se utiliza para instanciar un modelo Nemotron H Omni según los argumentos especificados, definiendo la arquitectura del modelo. Instanciar una configuración con los valores predeterminados producirá una configuración similar a la de [nvidia/Nemotron-3-Nano-Omni-30B-A3B-Reasoning-BF16](https://huggingface.co/nvidia/Nemotron-3-Nano-Omni-30B-A3B-Reasoning-BF16)

Los objetos de configuración heredan de [PreTrainedConfig](/docs/transformers/v5.23.0/es/main_classes/configuration#transformers.PreTrainedConfig) y se pueden utilizar para controlar las salidas del modelo. Consulte la documentación de [PreTrainedConfig](/docs/transformers/v5.23.0/es/main_classes/configuration#transformers.PreTrainedConfig) para obtener más información.

## NemotronH_Omni_Reasoning_V3ImageProcessor[[transformers.NemotronH_Omni_Reasoning_V3ImageProcessor]]

#### transformers.NemotronH_Omni_Reasoning_V3ImageProcessor[[transformers.NemotronH_Omni_Reasoning_V3ImageProcessor]]

```python
transformers.NemotronH_Omni_Reasoning_V3ImageProcessor(**kwargs: *<class 'transformers.models.nemotron_h_omni.image_processing_nemotron_h_omni.NemotronH_Omni_Reasoning_V3ImageProcessorKwargs'>)
```

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/nemotron_h_omni/image_processing_nemotron_h_omni.py#L98)

**Parámetros:**

do_convert_rgb (`bool`, *kwargs*, *opcional*, valor predeterminado `True`) : Si se debe convertir la imagen a RGB.

do_resize (`bool`, *kwargs*, *opcional*) : Si se debe redimensionar la imagen.

size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*) : Describe las dimensiones máximas de entrada del modelo.

default_to_square (`bool`, *kwargs*, *opcional*, valor predeterminado `True`) : Si se debe usar una imagen cuadrada por defecto al redimensionar, cuando el tamaño es un entero.

crop_size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*) : Tamaño de la imagen de salida tras aplicar `center_crop`.

resample (`Annotated[Union[int, PILImageResampling, NoneType], None]`, *kwargs*, por defecto `3`) : Filtro de remuestreo a utilizar si se redimensiona la imagen. Puede ser uno de los valores de la enumeración `PILImageResampling`. Solo tiene efecto si `do_resize` está establecido en `True`.

do_rescale (`bool`, *kwargs*, *opcional*, valor predeterminado `True`) : Indica si se debe reescalar la imagen.

rescale_factor (`float`, *kwargs*, *opcional*, valor predeterminado `0.00392156862745098`) : Factor de reescalado para reescalar la imagen si `do_rescale` está establecido en `True`.

do_normalize (`bool`, *kwargs*, *opcional*, valor predeterminado `True`) : Si se debe normalizar la imagen.

image_mean (`Union[float, list[float], tuple[float, ...]]`, *kwargs*, *opcional*, valor predeterminado `[0.48145466, 0.4578275, 0.40821073]`) : Media de la imagen a utilizar para la normalización. Solo tiene efecto si `do_normalize` está establecido en `True`.

image_std (`Union[float, list[float], tuple[float, ...]]`, *kwargs*, *opcional*, valor predeterminado `[0.26862954, 0.26130258, 0.27577711]`) : Desviación estándar de la imagen a utilizar para la normalización. Solo tiene efecto si `do_normalize` se establece en `True`.

do_pad (`bool`, *kwargs*, *opcional*) : Indica si se debe aplicar relleno a la imagen. El relleno se realiza hasta el tamaño más grande del lote o hasta un tamaño cuadrado fijo por imagen. La estrategia exacta de relleno depende del modelo.

pad_size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*) : El tamaño en `{"height": int, "width" int}` al que se rellenan las imágenes. Debe ser mayor que el tamaño de cualquier imagen proporcionada para el preprocesamiento. Si no se proporciona `pad_size`, las imágenes se rellenarán hasta la mayor altura y anchura del lote. Se aplica solo cuando `do_pad=True.`

do_center_crop (`bool`, *kwargs*, *opcional*) : Si se debe recortar la imagen centrada.

data_format (`Union[str, ~image_utils.ChannelDimension]`, *kwargs*, *opcional*) : Solo se admite `ChannelDimension.FIRST`. Se añadió para garantizar la compatibilidad con los procesadores lentos.

input_data_format (`Union[str, ~image_utils.ChannelDimension]`, *kwargs*, *opcional*) : El formato de la dimensión de canal para la imagen de entrada. Si no se establece, el formato de la dimensión de canal se infiere a partir de la imagen de entrada. Puede ser uno de: - `"channels_first"` o `ChannelDimension.FIRST`: imagen en formato (num_channels, height, width). - `"channels_last"` o `ChannelDimension.LAST`: imagen en formato (height, width, num_channels). - `"none"` o `ChannelDimension.NONE`: imagen en formato (height, width).

device (`Annotated[Union[str, torch.device, NoneType], None]`, *kwargs*) : El dispositivo en el que se procesarán los vídeos. Si no se establece, el dispositivo se infiere a partir de los vídeos de entrada.

return_tensors (`Annotated[str | ~utils.generic.TensorType | None, None]`, *kwargs*) : Devuelve tensores apilados si se establece en `'pt'`; en caso contrario, devuelve una lista de tensores.

disable_grouping (`bool`, *kwargs*, *opcional*) : Si se debe deshabilitar el agrupamiento de imágenes por tamaño para procesarlas de forma individual y no en lotes. Si es None, se establecerá en True si las imágenes están en CPU, y en False en caso contrario. Esta elección se basa en observaciones empíricas, como se detalla aquí: https://github.com/huggingface/transformers/pull/38157

image_seq_length (`int`, *kwargs*, *opcional*) : El número de tokens de imagen que se utilizarán para cada imagen en la entrada. Se añadió por compatibilidad con versiones anteriores, pero en los modelos futuros esto debería configurarse como un atributo del procesador.

patch_size (`int`, *kwargs*, *opcional*, valor predeterminado 16) : Longitud del lado, en píxeles, de un parche de la torre visual.

downsample_ratio (`float`, *kwargs*, *opcional*, valor predeterminado 0.5) : Relación de submuestreo espacial por pixel-shuffle aplicada por el modelo; cada lado de la cuadrícula de parches es un múltiplo de su recíproco.

min_num_patches (`int`, *kwargs*, *opcional*, valor predeterminado 1024) : Número mínimo de parches de `patch_size` al que se redimensiona una imagen.

max_num_patches (`int`, *kwargs*, *opcional*, valor predeterminado 13312) : Número máximo de parches de `patch_size` a los que se redimensiona una imagen; `0` desactiva el límite.

max_model_len (`int`, *kwargs*, *opcional*, valor predeterminado 16384) : Longitud de contexto del modelo de lenguaje, que limita el presupuesto de parches de las imágenes en una sola llamada.

Construye un procesador de imágenes NemotronH_Omni_Reasoning_V3ImageProcessor.

#### preprocess[[transformers.NemotronH_Omni_Reasoning_V3ImageProcessor.preprocess]]

```python
preprocess(images, **kwargs: *<class 'transformers.models.nemotron_h_omni.image_processing_nemotron_h_omni.NemotronH_Omni_Reasoning_V3ImageProcessorKwargs'>)
```

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/nemotron_h_omni/image_processing_nemotron_h_omni.py#L122)

**Parámetros:**

images (``) : Image to preprocess. Expects a single or batch of images with pixel values ranging from 0 to 255. If passing in images with pixel values between 0 and 1, set `do_rescale=False`.

do_convert_rgb (`bool`, *kwargs*, *opcional*) : Si se debe convertir la imagen a RGB.

do_resize (`bool`, *kwargs*, *opcional*) : Si se debe redimensionar la imagen.

size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*) : Describe las dimensiones máximas de entrada del modelo.

default_to_square (`bool`, *kwargs*, *opcional*) : Si el tamaño es un entero, si se debe usar una imagen cuadrada por defecto al redimensionar.

crop_size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*) : Tamaño de la imagen de salida tras aplicar `center_crop`.

resample (`Annotated[Union[int, PILImageResampling, NoneType], None]`, *kwargs*) : Filtro de remuestreo que se utilizará si se redimensiona la imagen. Puede ser uno de los valores de la enumeración `PILImageResampling`. Solo tiene efecto si `do_resize` está establecido en `True`.

do_rescale (`bool`, *kwargs*, *opcional*) : Si se debe reescalar la imagen.

rescale_factor (`float`, *kwargs*, *opcional*) : Factor de reescalado para reescalar la imagen si `do_rescale` está establecido en `True`.

do_normalize (`bool`, *kwargs*, *opcional*) : Si se debe normalizar la imagen.

image_mean (`Union[float, list[float], tuple[float, ...]]`, *kwargs*, *opcional*) : Media de la imagen a utilizar para la normalización. Solo tiene efecto si `do_normalize` está establecido en `True`.

image_std (`Union[float, list[float], tuple[float, ...]]`, *kwargs*, *opcional*) : Desviación estándar de la imagen a utilizar para la normalización. Solo tiene efecto si `do_normalize` está establecido en `True`.

do_pad (`bool`, *kwargs*, *opcional*) : Indica si se debe aplicar relleno a la imagen. El relleno se realiza hasta el tamaño más grande del lote o hasta un tamaño cuadrado fijo por imagen. La estrategia exacta de relleno depende del modelo.

pad_size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*) : El tamaño en `{"height": int, "width" int}` al que se rellenan las imágenes. Debe ser mayor que el tamaño de cualquier imagen proporcionada para el preprocesamiento. Si no se proporciona `pad_size`, las imágenes se rellenarán hasta la mayor altura y anchura del lote. Se aplica solo cuando `do_pad=True.`

do_center_crop (`bool`, *kwargs*, *opcional*) : Si se debe recortar la imagen centrada.

data_format (`Union[str, ~image_utils.ChannelDimension]`, *kwargs*, *opcional*) : Solo se admite `ChannelDimension.FIRST`. Se añadió para garantizar la compatibilidad con los procesadores lentos.

input_data_format (`Union[str, ~image_utils.ChannelDimension]`, *kwargs*, *opcional*) : El formato de la dimensión de canal para la imagen de entrada. Si no se establece, el formato de la dimensión de canal se infiere a partir de la imagen de entrada. Puede ser uno de: - `"channels_first"` o `ChannelDimension.FIRST`: imagen en formato (num_channels, height, width). - `"channels_last"` o `ChannelDimension.LAST`: imagen en formato (height, width, num_channels). - `"none"` o `ChannelDimension.NONE`: imagen en formato (height, width).

device (`Annotated[Union[str, torch.device, NoneType], None]`, *kwargs*) : El dispositivo en el que se procesarán los vídeos. Si no se establece, el dispositivo se infiere a partir de los vídeos de entrada.

return_tensors (`Annotated[str | ~utils.generic.TensorType | None, None]`, *kwargs*) : Devuelve tensores apilados si se establece en `'pt'`; en caso contrario, devuelve una lista de tensores.

disable_grouping (`bool`, *kwargs*, *opcional*) : Si se debe deshabilitar el agrupamiento de imágenes por tamaño para procesarlas de forma individual y no en lotes. Si es None, se establecerá en True si las imágenes están en CPU, y en False en caso contrario. Esta elección se basa en observaciones empíricas, como se detalla aquí: https://github.com/huggingface/transformers/pull/38157

image_seq_length (`int`, *kwargs*, *opcional*) : El número de tokens de imagen que se utilizarán para cada imagen en la entrada. Se añadió por compatibilidad con versiones anteriores, pero en los modelos futuros esto debería configurarse como un atributo del procesador.

patch_size (`int`, *kwargs*, *opcional*, valor predeterminado 16) : Longitud del lado, en píxeles, de un parche de la torre visual.

downsample_ratio (`float`, *kwargs*, *opcional*, valor predeterminado 0.5) : Relación de submuestreo espacial por pixel-shuffle aplicada por el modelo; cada lado de la cuadrícula de parches es un múltiplo de su recíproco.

min_num_patches (`int`, *kwargs*, *opcional*, valor predeterminado 1024) : Número mínimo de parches de `patch_size` al que se redimensiona una imagen.

max_num_patches (`int`, *kwargs*, *opcional*, valor predeterminado 13312) : Número máximo de parches de `patch_size` a los que se redimensiona una imagen; `0` desactiva el límite.

max_model_len (`int`, *kwargs*, *opcional*, valor predeterminado 16384) : Longitud de contexto del modelo de lenguaje, que limita el presupuesto de parches de las imágenes en una sola llamada.

**Devuelve:** `~image_processing_base.BatchFeature`

- **data** (`dict`) -- Diccionario de listas/arrays/tensores devueltos por el método __call__ ('pixel_values', etc.).
- **tensor_type** (`Union[None, str, TensorType]`, *opcional*) -- Puede especificar un tensor_type aquí para convertir las listas de enteros en Tensors de PyTorch/Numpy durante la inicialización.

## NemotronH_Omni_Reasoning_V3VideoProcessor[[transformers.NemotronH_Omni_Reasoning_V3VideoProcessor]]

#### transformers.NemotronH_Omni_Reasoning_V3VideoProcessor[[transformers.NemotronH_Omni_Reasoning_V3VideoProcessor]]

```python
transformers.NemotronH_Omni_Reasoning_V3VideoProcessor(**kwargs: *<class 'transformers.models.nemotron_h_omni.video_processing_nemotron_h_omni.NemotronH_Omni_Reasoning_V3VideoProcessorInitKwargs'>)
```

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/nemotron_h_omni/video_processing_nemotron_h_omni.py#L54)

**Parámetros:**

- ****kwargs** (`NemotronH_Omni_Reasoning_V3VideoProcessorInitKwargs`, *opcional*) : Opciones de procesamiento adicionales para cada modalidad (texto, imágenes, vídeos, audio). Los parámetros específicos del modelo se enumeran arriba; consulte la clase TypedDict para obtener la lista completa de argumentos admitidos.

Construye un procesador de video NemotronH_Omni_Reasoning_V3VideoProcessor.

## NemotronH_Omni_Reasoning_V3Processor[[transformers.NemotronH_Omni_Reasoning_V3Processor]]

#### transformers.NemotronH_Omni_Reasoning_V3Processor[[transformers.NemotronH_Omni_Reasoning_V3Processor]]

```python
transformers.NemotronH_Omni_Reasoning_V3Processor(image_processor = None, video_processor = None, tokenizer = None, feature_extractor = None, chat_template = None, audio_sampling_rate: int = 16000, audio_subsampling_factor: int = 8, audio_hop_length: int = 160, video_temporal_patch_dim: int = 2, **kwargs)
```

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/nemotron_h_omni/processing_nemotron_h_omni.py#L40)

**Parámetros:**

image_processor (`NemotronH_Omni_Reasoning_V3ImageProcessor`) : El procesador de imágenes es una entrada obligatoria.

video_processor (`NemotronH_Omni_Reasoning_V3VideoProcessor`) : El procesador de video es una entrada obligatoria.

tokenizer (`tokenizer_class`): El tokenizador es una entrada obligatoria.

feature_extractor (`feature_extractor_class`) : El extractor de características es una entrada obligatoria.

chat_template (`str`) : Una plantilla de Jinja para convertir listas de mensajes de un chat en una cadena tokenizable.

audio_sampling_rate (`int`, *opcional*, valor predeterminado 16000) : Tasa de muestreo, en Hz, a la que se espera que estén las formas de onda de audio.

audio_subsampling_factor (`int`, *opcional*, valor predeterminado 8) : Factor por el cual el codificador de sonido realiza el subsampleo de los fotogramas mel, utilizado para dimensionar la secuencia del marcador de posición de audio.

audio_hop_length (`int`, *opcional*, valor predeterminado 160) : Longitud del salto, en muestras, entre los fotogramas mel consecutivos.

video_temporal_patch_dim (`int`, *opcional*, valor predeterminado: 2) : Número de fotogramas que el incrustador de video del modelo agrupa en un solo parche temporal.

Construye un NemotronH_Omni_Reasoning_V3Processor que encapsula un procesador de imágenes, un procesador de video, un tokenizador y un extractor de características en un único procesador.

[NemotronH_Omni_Reasoning_V3Processor](/docs/transformers/v5.23.0/es/model_doc/nemotron_h_omni#transformers.NemotronH_Omni_Reasoning_V3Processor) ofrece todas las funcionalidades de [NemotronH_Omni_Reasoning_V3ImageProcessor](/docs/transformers/v5.23.0/es/model_doc/nemotron_h_omni#transformers.NemotronH_Omni_Reasoning_V3ImageProcessor), [NemotronH_Omni_Reasoning_V3VideoProcessor](/docs/transformers/v5.23.0/es/model_doc/nemotron_h_omni#transformers.NemotronH_Omni_Reasoning_V3VideoProcessor), `tokenizer_class` y `feature_extractor_class`. Consulte [~NemotronH_Omni_Reasoning_V3ImageProcessor](/docs/transformers/v5.23.0/es/model_doc/nemotron_h_omni#transformers.NemotronH_Omni_Reasoning_V3ImageProcessor), [~NemotronH_Omni_Reasoning_V3VideoProcessor](/docs/transformers/v5.23.0/es/model_doc/nemotron_h_omni#transformers.NemotronH_Omni_Reasoning_V3VideoProcessor), `~tokenizer_class` y `~feature_extractor_class` para obtener más información.

#### batch_decode[[transformers.NemotronH_Omni_Reasoning_V3Processor.batch_decode]]

```python
batch_decode(*args, **kwargs)
```

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/nemotron_h_omni/processing_nemotron_h_omni.py#L253)

Reenviar al [batch_decode()](/docs/transformers/v5.23.0/es/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.batch_decode) del tokenizador.

#### decode[[transformers.NemotronH_Omni_Reasoning_V3Processor.decode]]

```python
decode(*args, **kwargs)
```

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/nemotron_h_omni/processing_nemotron_h_omni.py#L257)

Reenviar al método [decode()](/docs/transformers/v5.23.0/es/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.decode) del tokenizador.

#### post_process_image_text_to_text[[transformers.NemotronH_Omni_Reasoning_V3Processor.post_process_image_text_to_text]]

```python
post_process_image_text_to_text(generated_outputs, skip_special_tokens = True, clean_up_tokenization_spaces = False, **kwargs)
```

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/nemotron_h_omni/processing_nemotron_h_omni.py#L261)

Decodifica los ids de tokens generados por el modelo en texto.

#### replace_video_token[[transformers.NemotronH_Omni_Reasoning_V3Processor.replace_video_token]]

```python
replace_video_token(video_inputs: dict, video_idx: int, **kwargs)
```

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/nemotron_h_omni/processing_nemotron_h_omni.py#L164)

Expanda `<video>` en un fragmento `<img>...</img>` por parche temporal (tubelet).

Cada fragmento se etiqueta con las marcas de tiempo de los fotogramas que contiene, unidas por " and " ("Frame" para el primer fotograma del tubelet, "frame" para el resto). El tokenizador no tiene un token real de `<video>`, por lo que los fragmentos utilizan el token de imagen; el modelo distingue entre imagen y vídeo según el argumento `pixel_values_*` que se haya pasado.

## NemotronH_Omni_Reasoning_V3[[transformers.NemotronH_Omni_Reasoning_V3]]

#### transformers.NemotronH_Omni_Reasoning_V3[[transformers.NemotronH_Omni_Reasoning_V3]]

```python
transformers.NemotronH_Omni_Reasoning_V3(config: NemotronH_Omni_Reasoning_V3_Config)
```

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/nemotron_h_omni/modeling_nemotron_h_omni.py#L142)

#### forward[[transformers.NemotronH_Omni_Reasoning_V3.forward]]

```python
forward(input_ids: typing.Optional[torch.LongTensor] = None, pixel_values: typing.Optional[torch.Tensor] = None, image_grid_hw: typing.Optional[torch.LongTensor] = None, pixel_values_videos: typing.Optional[torch.Tensor] = None, input_features: typing.Optional[torch.Tensor] = None, input_features_mask: typing.Optional[torch.Tensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, position_ids: typing.Optional[torch.LongTensor] = None, past_key_values: transformers.cache_utils.Cache | None = None, labels: typing.Optional[torch.LongTensor] = None, inputs_embeds: typing.Optional[torch.Tensor] = None, use_cache: bool | None = None, mm_encoder_outputs: dict[str, transformers.modeling_outputs.BaseModelOutputWithPooling] | None = None, **kwargs: *<class 'transformers.utils.generic.TransformersKwargs'>)
```

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/nemotron_h_omni/modeling_nemotron_h_omni.py#L347)

**Parámetros:**

input_ids (`torch.LongTensor` de forma `(batch_size, sequence_length)`, *opcional*) : Índices de los tokens de la secuencia de entrada en el vocabulario. El relleno se ignorará de forma predeterminada. Los índices se pueden obtener mediante [AutoTokenizer](/docs/transformers/v5.23.0/es/model_doc/auto#transformers.AutoTokenizer). Consulte [PreTrainedTokenizer.encode()](/docs/transformers/v5.23.0/es/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) y [PreTrainedTokenizer.__call__()](/docs/transformers/v5.23.0/es/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) para obtener más detalles. [¿Qué son los IDs de entrada?](../glossary#input-ids)

pixel_values (`torch.Tensor` de forma `(total_patches, num_channels * patch_size**2)`, *opcional*) : Patches aplanados de todas las imágenes, concatenados, tal como los devuelve el procesador de imágenes.

image_grid_hw (`torch.LongTensor` de forma `(num_images, 2)`, *opcional*) : Cuadrícula de parches `(height, width)` de cada imagen en `pixel_values`.

pixel_values_videos (`torch.Tensor` de forma `(batch_size, num_frames, num_channels, frame_size, frame_size)`, *opcional*) : Los tensores correspondientes al video de entrada. Los valores de píxel de los videos se pueden obtener usando [NemotronH_Omni_Reasoning_V3VideoProcessor](/docs/transformers/v5.23.0/es/model_doc/nemotron_h_omni#transformers.NemotronH_Omni_Reasoning_V3VideoProcessor). Consulte [NemotronH_Omni_Reasoning_V3Processor.__call__()](/docs/transformers/v5.23.0/es/model_doc/molmo2#transformers.Molmo2VideoProcessor.__call__) para más detalles ([NemotronH_Omni_Reasoning_V3Processor](/docs/transformers/v5.23.0/es/model_doc/nemotron_h_omni#transformers.NemotronH_Omni_Reasoning_V3Processor) utiliza [NemotronH_Omni_Reasoning_V3VideoProcessor](/docs/transformers/v5.23.0/es/model_doc/nemotron_h_omni#transformers.NemotronH_Omni_Reasoning_V3VideoProcessor) para procesar videos).

input_features (`torch.Tensor` de forma `(batch_size, num_frames, num_mel_bins)`, *opcional*) : Características Mel producidas por el procesador, codificadas y distribuidas sobre los tokens de marcador de posición de audio.

input_features_mask (`torch.Tensor` de forma `(batch_size, num_frames)`, *opcional*) : Máscara que marca los cuadros mel reales de cada clip relleno.

attention_mask (`torch.Tensor` de forma `(batch_size, sequence_length)`, *opcional*) : Máscara para evitar realizar atención en los índices de tokens de relleno. Valores de la máscara seleccionados en `[0, 1]`:  - 1 para tokens que **no están enmascarados**, - 0 para tokens que **están enmascarados**.  [¿Qué son las máscaras de atención?](../glossary#attention-mask)

position_ids (`torch.LongTensor` de forma `(batch_size, sequence_length)`, *opcional*) : Índices de las posiciones de los tokens de cada secuencia de entrada en las incrustaciones de posición. Seleccionados en el rango `[0, config.n_positions - 1]`.  [¿Qué son los IDs de posición?](../glossary#position-ids)

past_key_values (`~cache_utils.Cache`, *opcional*) : Estados ocultos precalculados (claves y valores en los bloques de autoatención y en los bloques de atención cruzada) que se pueden utilizar para acelerar la decodificación secuencial. Esto suele consistir en los `past_key_values` devueltos por el modelo en una etapa anterior de la decodificación, cuando `use_cache=True` o `config.use_cache=True`.  Solo se permite una instancia de [Cache](/docs/transformers/v5.23.0/es/internal/generation_utils#transformers.Cache) como entrada, consulte nuestra [guía de caché kv](https://huggingface.co/docs/transformers/en/kv_cache). Si no se pasan `past_key_values`, se inicializará [DynamicCache](/docs/transformers/v5.23.0/es/internal/generation_utils#transformers.DynamicCache) de forma predeterminada.  El modelo devolverá el mismo formato de caché que se haya proporcionado como entrada.  Si se utilizan `past_key_values`, se espera que el usuario introduzca solo los `input_ids` no procesados (aquellos que no tienen sus estados de clave y valor previos dados a este modelo) con forma `(batch_size, unprocessed_length)` en lugar de todos los `input_ids` con forma `(batch_size, sequence_length)`.

labels (`torch.LongTensor` de forma `(batch_size, sequence_length)`, *opcional*) : Etiquetas para calcular la pérdida de modelado de lenguaje enmascarado. Los índices deben estar en `[0, ..., config.vocab_size]` o ser -100 (consulte la docstring de `input_ids`). Los tokens con índices fijados en `-100` se ignoran (se enmascaran); la pérdida solo se calcula para los tokens con etiquetas en `[0, ..., config.vocab_size]`.

inputs_embeds (`torch.Tensor` de forma `(batch_size, sequence_length, hidden_size)`, *opcional*) : Opcionalmente, en lugar de pasar `input_ids`, puedes elegir pasar directamente una representación incrustada. Esto es útil si deseas tener más control sobre cómo convertir los índices de `input_ids` en los vectores asociados que en la matriz de búsqueda de incrustaciones interna del modelo.

use_cache (`bool`, *opcional*) : Si se establece en `True`, se devuelven los estados de valores clave `past_key_values` y pueden usarse para acelerar la decodificación (ver `past_key_values`).

mm_encoder_outputs (`dict[str, ~modeling_outputs.BaseModelOutputWithPooling]`, *opcional*) : Diccionario donde las claves son las modalidades admitidas y los valores son las salidas codificadas para esa modalidad. Cada salida codificada es una tupla que consiste en (`pooler_output`, *opcional*: `last_hidden_states`, *opcional*: `hidden_states`, *opcional*: `attentions`) `pooler_output` de forma `(batch_size, sequence_length, hidden_size)`, *opcional*) es una secuencia de características multimodales del codificador fusionadas en las incrustaciones de texto.

**Devuelve:** [CausalLMOutputWithPast](/docs/transformers/v5.23.0/es/main_classes/output#transformers.modeling_outputs.CausalLMOutputWithPast) o `tuple(torch.Tensor)`

Un [CausalLMOutputWithPast](/docs/transformers/v5.23.0/es/main_classes/output#transformers.modeling_outputs.CausalLMOutputWithPast) o una tupla de `torch.Tensor` (si se pasa `return_dict=False` o cuando `config.return_dict=False`) que comprende varios elementos según la configuración ([NemotronH_Omni_Reasoning_V3_Config](/docs/transformers/v5.23.0/es/model_doc/nemotron_h_omni#transformers.NemotronH_Omni_Reasoning_V3_Config)) y las entradas.

El método forward de [NemotronH_Omni_Reasoning_V3](/docs/transformers/v5.23.0/es/model_doc/nemotron_h_omni#transformers.NemotronH_Omni_Reasoning_V3) sobrescribe el método especial `__call__`.

Aunque la receta para la pasada hacia adelante debe definirse dentro de esta función, se debe llamar a la instancia de `Module` después, en lugar de a esta, ya que la primera se encarga de ejecutar los pasos de preprocesamiento y posprocesamiento, mientras que la segunda los ignora silenciosamente.

- **loss** (`torch.Tensor` de forma `(1,)`, *opcional*, se devuelve cuando se proporciona `labels`) -- Pérdida de modelado de lenguaje (para la predicción del siguiente token).
- **logits** (`torch.Tensor` de forma `(batch_size, sequence_length, config.vocab_size)`) -- Puntuaciones de predicción de la cabeza de modelado de lenguaje (puntuaciones para cada token del vocabulario antes de SoftMax).
- **past_key_values** (`Cache`, *opcional*, se devuelve cuando se pasa `use_cache=True` o cuando `config.use_cache=True`) -- Es una instancia de [Cache](/docs/transformers/v5.23.0/es/internal/generation_utils#transformers.Cache). Para más detalles, consulte nuestra [guía de caché kv](https://huggingface.co/docs/transformers/en/kv_cache).

  Contiene estados ocultos precalculados (claves y valores en los bloques de autoatención) que pueden utilizarse (véase la entrada `past_key_values`) para acelerar la decodificación secuencial.
- **hidden_states** (`tuple(torch.Tensor)`, *opcional*, se devuelve cuando se pasa `output_hidden_states=True` o cuando `config.output_hidden_states=True`) -- Tupla de `torch.Tensor` (una para la salida de los embeddings, si el modelo tiene una capa de embedding, + una para la salida de cada capa) de forma `(batch_size, sequence_length, hidden_size)`.

  Estados ocultos del modelo en la salida de cada capa más las salidas opcionales de la incrustación inicial.
- **attentions** (`tuple(torch.Tensor)`, *opcional*, se devuelve cuando se pasa `output_attentions=True` o cuando `config.output_attentions=True`) -- Tupla de `torch.Tensor` (una por cada capa) de forma `(batch_size, num_heads, sequence_length, sequence_length)`.

  Pesos de atención tras el softmax de atención, utilizados para calcular la media ponderada en las cabezas de autoatención.

Ejemplo:

```python
>>> from PIL import Image
>>> from transformers import AutoProcessor, NemotronH_Omni_Reasoning_V3

>>> model = NemotronH_Omni_Reasoning_V3.from_pretrained("nvidia/Nemotron-3-Nano-Omni-30B-A3B-Reasoning-BF16")
>>> processor = AutoProcessor.from_pretrained("nvidia/Nemotron-3-Nano-Omni-30B-A3B-Reasoning-BF16")

>>> messages = [
...     {
...         "role": "user", "content": [
...             {"type": "image", "url": "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/pipeline-cat-chonk.jpeg"},
...             {"type": "text", "text": "Where is the cat standing?"},
...         ]
...     },
... ]

>>> inputs = processor.apply_chat_template(
...     messages,
...     tokenize=True,
...     return_dict=True,
...     return_tensors="pt",
...     add_generation_prompt=True
... )
>>> # Generate
>>> generate_ids = model.generate(**inputs)
>>> processor.batch_decode(generate_ids, skip_special_tokens=True)[0]
```

#### generate[[transformers.NemotronH_Omni_Reasoning_V3.generate]]

```python
generate(inputs: typing.Optional[torch.Tensor] = None, generation_config: transformers.generation.configuration_utils.GenerationConfig | None = None, logits_processor: transformers.generation.logits_process.LogitsProcessorList | None = None, stopping_criteria: transformers.generation.stopping_criteria.StoppingCriteriaList | None = None, prefix_allowed_tokens_fn: collections.abc.Callable[[int, torch.Tensor], list[int]] | None = None, synced_gpus: bool | None = None, assistant_model: typing.Optional[ForwardRef('PreTrainedModel')] = None, streamer: typing.Optional[ForwardRef('BaseStreamer')] = None, negative_prompt_ids: typing.Optional[torch.Tensor] = None, negative_prompt_attention_mask: typing.Optional[torch.Tensor] = None, custom_generate: str | collections.abc.Callable | None = None, **kwargs)
```

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/generation/utils.py#L2581)

**Parámetros:**

inputs (`torch.Tensor` de forma variable según la modalidad, *opcional*) : La secuencia utilizada como indicación para la generación o como entradas del modelo para el codificador. Si es `None`, el método la inicializa con `bos_token_id` y un tamaño de lote de 1. Para modelos solo de decodificador, `inputs` debe estar en el formato de `input_ids`. Para modelos codificador-decodificador, *inputs* puede representar cualquiera de `input_ids`, `input_values`, `input_features` o `pixel_values`.

generation_config ([GenerationConfig](/docs/transformers/v5.23.0/es/main_classes/text_generation#transformers.GenerationConfig), *opcional*) : La configuración de generación que se utilizará como parametrización base para la llamada de generación. Los `**kwargs` pasados a generate que coincidan con los atributos de `generation_config` los sobrescribirán. Si no se proporciona `generation_config`, se utilizará la predeterminada, que tiene la siguiente prioridad de carga: 1) desde el archivo de modelo `generation_config.json`, si existe; 2) desde la configuración del modelo. Tenga en cuenta que los parámetros no especificados heredarán los valores predeterminados de [GenerationConfig](/docs/transformers/v5.23.0/es/main_classes/text_generation#transformers.GenerationConfig), cuya documentación debe consultarse para parametrizar la generación.

logits_processor (`LogitsProcessorList`, *opcional*) : Procesadores de logits personalizados que complementan los procesadores de logits predeterminados creados a partir de los argumentos y la configuración de generación. Si se pasa un procesador de logits que ya ha sido creado con los argumentos o una configuración de generación, se lanza un error. Esta función está destinada a usuarios avanzados.

stopping_criteria (`StoppingCriteriaList`, *opcional*) : Criterios de parada personalizados que complementan los criterios de parada predeterminados construidos a partir de los argumentos y una configuración de generación. Si se pasa un criterio de parada que ya ha sido creado con los argumentos o una configuración de generación, se lanza un error. Si su criterio de parada depende de la entrada `scores`, asegúrese de pasar `return_dict_in_generate=True, output_scores=True` a `generate`. Esta función está destinada a usuarios avanzados.

prefix_allowed_tokens_fn (`Callable[[int, torch.Tensor], list[int]]`, *opcional*) : Si se proporciona, esta función restringe la búsqueda por haz a los tokens permitidos en cada paso. Si no se proporciona, no se aplica ninguna restricción. Esta función toma 2 argumentos: el ID del lote `batch_id` y `input_ids`. Debe devolver una lista con los tokens permitidos para el siguiente paso de generación, condicionada al ID del lote `batch_id` y a los tokens generados previamente `inputs_ids`. Este argumento es útil para la generación restringida condicionada al prefijo, tal como se describe en [Autoregressive Entity Retrieval](https://huggingface.co/papers/2010.00904).

synced_gpus (`bool`, *opcional*) : Indica si se debe continuar ejecutando el bucle while hasta max_length. A menos que se sobrescriba, esta bandera se establecerá en `True` si se utiliza `FullyShardedDataParallel` o DeepSpeed ZeRO Stage 3 con varias GPUs, para evitar bloqueos si una GPU termina de generar antes que las demás. De lo contrario, el valor predeterminado es `False`.

assistant_model (`PreTrainedModel`, *opcional*) : Un modelo asistente que se puede utilizar para acelerar la generación. El modelo asistente debe tener exactamente el mismo tokenizador. La aceleración se logra cuando la predicción de tokens candidatos con el modelo asistente es mucho más rápida que ejecutar la generación con el modelo desde el que se llama a generate. Por lo tanto, el modelo asistente debe ser mucho más pequeño.

streamer (`BaseStreamer`, *opcional*) : Objeto Streamer que se utilizará para transmitir las secuencias generadas. Los tokens generados se pasan a través de `streamer.put(token_ids)` y el streamer se encarga de cualquier procesamiento adicional.

negative_prompt_ids (`torch.LongTensor` de forma `(batch_size, sequence_length)`, *opcional*) : El prompt negativo necesario para algunos procesadores, como CFG. El tamaño del lote debe coincidir con el tamaño del lote de entrada. Esta es una función experimental, sujeta a cambios que pueden romper la API en versiones futuras.

negative_prompt_attention_mask (`torch.LongTensor` de forma `(batch_size, sequence_length)`, *opcional*) : Attention_mask para `negative_prompt_ids`.

custom_generate (`str` o `Callable`, *opcional*) : Una de las siguientes opciones: - `str` (nombre de un repositorio de Hugging Face Hub): ejecuta la función personalizada `generate` definida en `custom_generate/generate.py` de ese repositorio en lugar del método estándar `generate`. El repositorio reemplaza por completo la lógica de generación, y el tipo de retorno puede diferir. - `str` (ruta de un repositorio local): igual que lo anterior, pero desde una ruta local. Los directorios locales también requieren `trust_remote_code=True` porque se ejecuta el `custom_generate/generate.py` local. - `Callable`: `generate` realizará los pasos habituales de preparación de la entrada y luego llamará al callable proporcionado para ejecutar el bucle de decodificación. Para obtener más información, consulte [la documentación](../../generation_strategies#custom-generation-methods).

kwargs (`dict[str, Any]`, *opcional*) : Parametrización ad hoc de `generation_config` y/o kwargs específicos del modelo adicionales que se reenviarán a la función `forward` del modelo. Si el modelo es un modelo encoder-decoder, los kwargs específicos del encoder no deben tener prefijo y los kwargs específicos del decoder deben tener el prefijo *decoder_*.

**Devuelve:** [ModelOutput](/docs/transformers/v5.23.0/es/main_classes/output#transformers.utils.ModelOutput) o `torch.LongTensor`

Un [ModelOutput](/docs/transformers/v5.23.0/es/main_classes/output#transformers.utils.ModelOutput) (si `return_dict_in_generate=True` o cuando `config.return_dict_in_generate=True`) o un `torch.LongTensor`.

Si el modelo *no* es un modelo encoder-decoder (`model.config.is_encoder_decoder=False`), los tipos [ModelOutput](/docs/transformers/v5.23.0/es/main_classes/output#transformers.utils.ModelOutput) posibles son:

- [GenerateDecoderOnlyOutput](/docs/transformers/v5.23.0/es/internal/generation_utils#transformers.generation.GenerateDecoderOnlyOutput),
- [GenerateBeamDecoderOnlyOutput](/docs/transformers/v5.23.0/es/internal/generation_utils#transformers.generation.GenerateBeamDecoderOnlyOutput)

Si el modelo es un modelo encoder-decoder (`model.config.is_encoder_decoder=True`), los tipos [ModelOutput](/docs/transformers/v5.23.0/es/main_classes/output#transformers.utils.ModelOutput) posibles son:

- [GenerateEncoderDecoderOutput](/docs/transformers/v5.23.0/es/internal/generation_utils#transformers.generation.GenerateEncoderDecoderOutput),
- [GenerateBeamEncoderDecoderOutput](/docs/transformers/v5.23.0/es/internal/generation_utils#transformers.generation.GenerateBeamEncoderDecoderOutput)

Genera secuencias de ids de tokens para modelos con una cabeza de modelado de lenguaje.

La mayoría de los parámetros de control de generación se configuran en `generation_config`, que, si no se pasa, se establecerá en la configuración de generación predeterminada del modelo. Puede invalidar cualquier `generation_config` pasando los parámetros correspondientes a generate(), por ejemplo, `.generate(inputs, num_beams=4, do_sample=True)`.

Para obtener una visión general de las estrategias de generación y ejemplos de código, consulta la [siguiente guía](../generation_strategies).

