# NemotronH Omni

NemotronH Omni é um modelo de raciocínio multimodal da NVIDIA que combina o modelo de linguagem híbrido Mamba-Transformer [NemotronH](./nemotron_h) com um codificador de visão [RADIO](./radio) e um codificador de som opcional baseado em Parakeet. Os patches de imagem (e vídeo) são projetados por meio de uma torre RADIO e um MLP de pixel-shuffle para o espaço de incorporação do modelo de linguagem nas posições dos tokens de contexto `<image>` / `<video>`; os clipes de áudio são projetados da mesma forma nas posições `<audio>`. O resultado é um único modelo autoregressivo que raciocina conjuntamente sobre texto, imagens, vídeo e som.

O exemplo abaixo demonstra como raciocinar sobre uma imagem e um prompt de texto com [AutoModelForImageTextToText](/docs/transformers/main/pt/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)
```

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

**Parâmetros:**

vision_config (`dict` ou `RadioConfig`, *opcional*) : Configuração para o codificador de visão do RADIO. O padrão é um [RadioConfig](/docs/transformers/main/pt/model_doc/radio#transformers.RadioConfig) padrão.

text_config (`dict` ou `NemotronHConfig`, *opcional*) : Configuração para o modelo de linguagem NemotronH. O padrão é um [NemotronHConfig](/docs/transformers/main/pt/model_doc/nemotron_h#transformers.NemotronHConfig) padrão.

audio_config (`dict` ou `ParakeetEncoderConfig`, *opcional*) : Configuração para o codificador de som Parakeet opcional. `None` desativa o ramo de áudio.

force_image_size (`int`, *opcional*) : Resolução fixa da imagem de entrada (em pixels) que a torre de visão espera.

downsample_ratio (`float`, *opcional*, padrão 0.5) : Razão de downsampling espacial por pixel-shuffle aplicada aos recursos visuais.

projector_hidden_size (`int`, *opcional*, padrão 4096) : Tamanho oculto do projetor MLP de visão para LLM.

vision_hidden_size (`int`, *opcional*, padrão 1280) : Tamanho oculto dos recursos visuais do RADIO.

video_pruning_rate (`float`, *opcional*, padrão 0.0) : taxa de poda de tokens do Efficient-Video-Sampling; `0.0` desativa a poda.

video_temporal_patch_size (`int`, *opcional*, padrão 2) : Número de quadros agregados em um único patch temporal pelo incorporador de vídeo.

image_token_id (`int`, *opcional*) : ID do token usado como marcador de contexto de imagem em `input_ids`.

video_token_id (`int`, *opcional*) : ID do token usado como marcador de contexto de vídeo em `input_ids`.

audio_token_id (`int`, *opcional*) : ID do token usado como marcador de contexto de áudio em `input_ids`.

Esta é a classe de configuração para armazenar a configuração de um Nemotron H OmniModel. Ela é usada para instanciar um modelo Nemotron H Omni de acordo com os argumentos especificados, definindo a arquitetura do modelo. Instanciar uma configuração com os padrões resultará em uma configuração semelhante à do [nvidia/Nemotron-3-Nano-Omni-30B-A3B-Reasoning-BF16](https://huggingface.co/nvidia/Nemotron-3-Nano-Omni-30B-A3B-Reasoning-BF16)

Os objetos de configuração herdam de [PreTrainedConfig](/docs/transformers/main/pt/main_classes/configuration#transformers.PreTrainedConfig) e podem ser usados para controlar as saídas do modelo. Leia a documentação de [PreTrainedConfig](/docs/transformers/main/pt/main_classes/configuration#transformers.PreTrainedConfig) para mais informações.

## 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'>)
```

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

**Parâmetros:**

do_convert_rgb (`bool`, *kwargs*, *opcional*, padrão `True`) : Se deve converter a imagem para RGB.

do_resize (`bool`, *kwargs*, *opcional*) : Se deve redimensionar a imagem.

size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*) : Descreve as dimensões máximas de entrada para o modelo.

default_to_square (`bool`, *kwargs*, *opcional*, padrão `True`) : Se deve usar uma imagem quadrada por padrão ao redimensionar, caso o tamanho seja um inteiro.

crop_size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*) : Tamanho da imagem de saída após aplicar `center_crop`.

resample (`Annotated[Union[int, PILImageResampling, NoneType], None]`, *kwargs*, padrão `3`) : Filtro de reamostragem a ser usado ao redimensionar a imagem. Pode ser um dos valores da enumeração `PILImageResampling`. Tem efeito apenas se `do_resize` estiver definido como `True`.

do_rescale (`bool`, *kwargs*, *opcional*, padrão `True`) : Se deve reescalar a imagem.

rescale_factor (`float`, *kwargs*, *opcional*, padrão `0.00392156862745098`) : Fator de redimensionamento para redimensionar a imagem, caso `do_rescale` esteja definido como `True`.

do_normalize (`bool`, *kwargs*, *opcional*, padrão `True`) : Se a imagem deve ser normalizada.

image_mean (`Union[float, list[float], tuple[float, ...]]`, *kwargs*, *opcional*, padrão `[0.48145466, 0.4578275, 0.40821073]`) : Média da imagem a ser usada para normalização. Tem efeito apenas se `do_normalize` estiver definido como `True`.

image_std (`Union[float, list[float], tuple[float, ...]]`, *kwargs*, *opcional*, padrão `[0.26862954, 0.26130258, 0.27577711]`) : Desvio padrão da imagem a ser usado para normalização. Tem efeito apenas se `do_normalize` estiver definido como `True`.

do_pad (`bool`, *kwargs*, *opcional*) : Se deve aplicar padding à imagem. O padding é feito até o maior tamanho do lote ou até um tamanho quadrado fixo por imagem. A estratégia exata de padding depende do modelo.

pad_size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*) : O tamanho em `{"height": int, "width" int}` para preencher as imagens. Deve ser maior que o tamanho de qualquer imagem fornecida para o pré-processamento. Se `pad_size` não for fornecido, as imagens serão preenchidas até a maior altura e largura do lote. Aplicado apenas quando `do_pad=True.`

do_center_crop (`bool`, *kwargs*, *opcional*) : Se deve centralizar o recorte da imagem.

data_format (`Union[str, ~image_utils.ChannelDimension]`, *kwargs*, *opcional*) : Apenas `ChannelDimension.FIRST` é suportado. Adicionado para compatibilidade com processadores lentos.

input_data_format (`Union[str, ~image_utils.ChannelDimension]`, *kwargs*, *opcional*) : O formato da dimensão de canal para a imagem de entrada. Se não for definido, o formato da dimensão de canal é inferido a partir da imagem de entrada. Pode ser um dos seguintes: - `"channels_first"` ou `ChannelDimension.FIRST`: imagem no formato (num_channels, height, width). - `"channels_last"` ou `ChannelDimension.LAST`: imagem no formato (height, width, num_channels). - `"none"` ou `ChannelDimension.NONE`: imagem no formato (height, width).

device (`Annotated[Union[str, torch.device, NoneType], None]`, *kwargs*) : O dispositivo no qual os vídeos serão processados. Se não for definido, o dispositivo é inferido a partir dos vídeos de entrada.

return_tensors (`Annotated[str | ~utils.generic.TensorType | None, None]`, *kwargs*) : Retorna tensores empilhados se definido como `'pt'`, caso contrário, retorna uma lista de tensores.

disable_grouping (`bool`, *kwargs*, *opcional*) : Se deve desabilitar o agrupamento de imagens por tamanho para processá-las individualmente e não em lotes. Se for None, será definido como True se as imagens estiverem na CPU, e False caso contrário. Essa escolha é baseada em observações empíricas, conforme detalhado aqui: https://github.com/huggingface/transformers/pull/38157

image_seq_length (`int`, *kwargs*, *opcional*) : O número de tokens de imagem a serem usados para cada imagem na entrada. Adicionado para compatibilidade reversa, mas isso deve ser definido como um atributo do processador em modelos futuros.

patch_size (`int`, *kwargs*, *opcional*, padrão 16) : Lado, em pixels, de um patch da torre de visão.

downsample_ratio (`float`, *kwargs*, *opcional*, padrão 0.5) : Razão de downsampling espacial por pixel-shuffle aplicada pelo modelo; cada lado da grade de patches é um múltiplo do seu inverso.

min_num_patches (`int`, *kwargs*, *opcional*, padrão 1024) : Número mínimo de patches de `patch_size` para os quais uma imagem é redimensionada.

max_num_patches (`int`, *kwargs*, *opcional*, padrão 13312) : Número máximo de patches de `patch_size` para os quais uma imagem é redimensionada; `0` desativa o limite.

max_model_len (`int`, *kwargs*, *opcional*, padrão 16384) : Comprimento do contexto do modelo de linguagem, que limita o orçamento de patches das imagens em uma única chamada.

Constrói um processador de imagem 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'>)
```

[Origem](https://github.com/huggingface/transformers/blob/main/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*) : Se deve converter a imagem para RGB.

do_resize (`bool`, *kwargs*, *opcional*) : Se deve redimensionar a imagem.

size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*) : Descreve as dimensões máximas de entrada para o modelo.

default_to_square (`bool`, *kwargs*, *opcional*) : Se deve usar uma imagem quadrada por padrão ao redimensionar, caso o tamanho seja um inteiro.

crop_size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*) : Tamanho da imagem de saída após aplicar `center_crop`.

resample (`Annotated[Union[int, PILImageResampling, NoneType], None]`, *kwargs*) : Filtro de redimensionamento a ser usado ao redimensionar a imagem. Pode ser um dos valores da enumeração `PILImageResampling`. Tem efeito apenas se `do_resize` estiver definido como `True`.

do_rescale (`bool`, *kwargs*, *opcional*) : Se deve reescalar a imagem.

rescale_factor (`float`, *kwargs*, *opcional*) : Fator de redimensionamento para redimensionar a imagem, caso `do_rescale` esteja definido como `True`.

do_normalize (`bool`, *kwargs*, *opcional*) : Se a imagem deve ser normalizada.

image_mean (`Union[float, list[float], tuple[float, ...]]`, *kwargs*, *opcional*) : Média da imagem a ser usada para normalização. Tem efeito apenas se `do_normalize` estiver definido como `True`.

image_std (`Union[float, list[float], tuple[float, ...]]`, *kwargs*, *opcional*) : Desvio padrão da imagem a ser usado para normalização. Tem efeito apenas se `do_normalize` estiver definido como `True`.

do_pad (`bool`, *kwargs*, *opcional*) : Se deve aplicar padding à imagem. O padding é feito até o maior tamanho do lote ou até um tamanho quadrado fixo por imagem. A estratégia exata de padding depende do modelo.

pad_size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*) : O tamanho em `{"height": int, "width" int}` para preencher as imagens. Deve ser maior que o tamanho de qualquer imagem fornecida para o pré-processamento. Se `pad_size` não for fornecido, as imagens serão preenchidas até a maior altura e largura do lote. Aplicado apenas quando `do_pad=True.`

do_center_crop (`bool`, *kwargs*, *opcional*) : Se deve centralizar o recorte da imagem.

data_format (`Union[str, ~image_utils.ChannelDimension]`, *kwargs*, *opcional*) : Apenas `ChannelDimension.FIRST` é suportado. Adicionado para compatibilidade com processadores lentos.

input_data_format (`Union[str, ~image_utils.ChannelDimension]`, *kwargs*, *opcional*) : O formato da dimensão de canal para a imagem de entrada. Se não for definido, o formato da dimensão de canal é inferido a partir da imagem de entrada. Pode ser um dos seguintes: - `"channels_first"` ou `ChannelDimension.FIRST`: imagem no formato (num_channels, height, width). - `"channels_last"` ou `ChannelDimension.LAST`: imagem no formato (height, width, num_channels). - `"none"` ou `ChannelDimension.NONE`: imagem no formato (height, width).

device (`Annotated[Union[str, torch.device, NoneType], None]`, *kwargs*) : O dispositivo no qual os vídeos serão processados. Se não for definido, o dispositivo é inferido a partir dos vídeos de entrada.

return_tensors (`Annotated[str | ~utils.generic.TensorType | None, None]`, *kwargs*) : Retorna tensores empilhados se definido como `'pt'`, caso contrário, retorna uma lista de tensores.

disable_grouping (`bool`, *kwargs*, *opcional*) : Se deve desabilitar o agrupamento de imagens por tamanho para processá-las individualmente e não em lotes. Se for None, será definido como True se as imagens estiverem na CPU, e False caso contrário. Essa escolha é baseada em observações empíricas, conforme detalhado aqui: https://github.com/huggingface/transformers/pull/38157

image_seq_length (`int`, *kwargs*, *opcional*) : O número de tokens de imagem a serem usados para cada imagem na entrada. Adicionado para compatibilidade reversa, mas isso deve ser definido como um atributo do processador em modelos futuros.

patch_size (`int`, *kwargs*, *opcional*, padrão 16) : Lado, em pixels, de um patch da torre de visão.

downsample_ratio (`float`, *kwargs*, *opcional*, padrão 0.5) : Razão de downsampling espacial por pixel-shuffle aplicada pelo modelo; cada lado da grade de patches é um múltiplo do seu inverso.

min_num_patches (`int`, *kwargs*, *opcional*, padrão 1024) : Número mínimo de patches de `patch_size` para os quais uma imagem é redimensionada.

max_num_patches (`int`, *kwargs*, *opcional*, padrão 13312) : Número máximo de patches de `patch_size` para os quais uma imagem é redimensionada; `0` desativa o limite.

max_model_len (`int`, *kwargs*, *opcional*, padrão 16384) : Comprimento do contexto do modelo de linguagem, que limita o orçamento de patches das imagens em uma única chamada.

**Retorna:** `~image_processing_base.BatchFeature`

- **data** (`dict`) -- Dicionário de listas/arrays/tensors retornados pelo método __call__ ('pixel_values', etc.).
- **tensor_type** (`Union[None, str, TensorType]`, *opcional*) -- Você pode fornecer um tensor_type aqui para converter as listas de inteiros em Tensors do PyTorch/Numpy na inicialização.

## 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'>)
```

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

**Parâmetros:**

- ****kwargs** (`NemotronH_Omni_Reasoning_V3VideoProcessorInitKwargs`, *opcional*) : Opções de processamento adicionais para cada modalidade (texto, imagens, vídeos, áudio). Os parâmetros específicos do modelo estão listados acima; consulte a classe TypedDict para a lista completa de argumentos suportados.

Constrói um processador de vídeo 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)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/nemotron_h_omni/processing_nemotron_h_omni.py#L44)

**Parâmetros:**

image_processor (`NemotronH_Omni_Reasoning_V3ImageProcessor`) : O processador de imagem é uma entrada obrigatória.

video_processor (`NemotronH_Omni_Reasoning_V3VideoProcessor`) : O processador de vídeo é uma entrada obrigatória.

tokenizer (`tokenizer_class`) : O tokenizer é uma entrada obrigatória.

feature_extractor (`feature_extractor_class`) : O extrator de recursos é uma entrada obrigatória.

chat_template (`str`) : Um modelo Jinja para converter listas de mensagens em um chat em uma string tokenizável.

audio_sampling_rate (`int`, *opcional*, padrão 16000) : Taxa de amostragem, em Hz, na qual as formas de onda de áudio são esperadas.

audio_subsampling_factor (`int`, *opcional*, padrão 8) : Fator pelo qual o codificador de som subsampleia os quadros mel, usado para dimensionar a execução do placeholder de áudio.

audio_hop_length (`int`, *opcional*, padrão 160) : Comprimento do salto, em amostras, entre os quadros mel consecutivos.

video_temporal_patch_dim (`int`, *opcional*, padrão 2) : Número de quadros agregados em um único patch temporal pelo incorporador de vídeo do modelo.

Constrói um NemotronH_Omni_Reasoning_V3Processor que encapsula um processador de imagem, um processador de vídeo, um tokenizer e um extrator de características em um único processador.

[NemotronH_Omni_Reasoning_V3Processor](/docs/transformers/main/pt/model_doc/nemotron_h_omni#transformers.NemotronH_Omni_Reasoning_V3Processor) oferece todas as funcionalidades de [NemotronH_Omni_Reasoning_V3ImageProcessor](/docs/transformers/main/pt/model_doc/nemotron_h_omni#transformers.NemotronH_Omni_Reasoning_V3ImageProcessor), [NemotronH_Omni_Reasoning_V3VideoProcessor](/docs/transformers/main/pt/model_doc/nemotron_h_omni#transformers.NemotronH_Omni_Reasoning_V3VideoProcessor), `tokenizer_class` e `feature_extractor_class`. Consulte [~NemotronH_Omni_Reasoning_V3ImageProcessor](/docs/transformers/main/pt/model_doc/nemotron_h_omni#transformers.NemotronH_Omni_Reasoning_V3ImageProcessor), [~NemotronH_Omni_Reasoning_V3VideoProcessor](/docs/transformers/main/pt/model_doc/nemotron_h_omni#transformers.NemotronH_Omni_Reasoning_V3VideoProcessor), `~tokenizer_class` e `~feature_extractor_class` para mais informações.

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

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

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/nemotron_h_omni/processing_nemotron_h_omni.py#L287)

Encaminha para o [batch_decode()](/docs/transformers/main/pt/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.batch_decode) do tokenizer.

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

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

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/nemotron_h_omni/processing_nemotron_h_omni.py#L291)

Encaminha para o [decode()](/docs/transformers/main/pt/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.decode) do tokenizer.

#### 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)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/nemotron_h_omni/processing_nemotron_h_omni.py#L295)

Decodifique os ids de tokens gerados pelo modelo em texto.

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

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

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/nemotron_h_omni/processing_nemotron_h_omni.py#L169)

Expanda `<video>` em um único `<img>...</img>` por patch temporal (tubelet).

Cada chunk é rotulado com os timestamps dos frames que ele contém, unidos por " and " ("Frame" para o primeiro frame no tubelet, "frame" para os demais). O tokenizer não possui um token real de `<video>`, então os chunks usam o token de imagem; o modelo distingue imagem de vídeo pelo argumento `pixel_values_*` que foi passado.

## 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)
```

[Origem](https://github.com/huggingface/transformers/blob/main/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'>)
```

[Origem](https://github.com/huggingface/transformers/blob/main/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 dos tokens da sequência de entrada no vocabulário. O preenchimento (padding) será ignorado por padrão. Os índices podem ser obtidos usando [AutoTokenizer](/docs/transformers/main/pt/model_doc/auto#transformers.AutoTokenizer). Consulte [PreTrainedTokenizer.encode()](/docs/transformers/main/pt/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) e [PreTrainedTokenizer.__call__()](/docs/transformers/main/pt/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) para mais detalhes. [O que são IDs de entrada?](../glossary#input-ids)

pixel_values (`torch.Tensor` de forma `(total_patches, num_channels * patch_size**2)`, *opcional*) : Patches achatados de todas as imagens, concatenados, conforme retornado pelo processador de imagem.

image_grid_hw (`torch.LongTensor` de shape `(num_images, 2)`, *opcional*) : Grade de patches `(height, width)` de cada imagem em `pixel_values`.

pixel_values_videos (`torch.Tensor` de forma `(batch_size, num_frames, num_channels, frame_size, frame_size)`, *opcional*) : Os tensores correspondentes ao vídeo de entrada. Os valores de pixels para vídeos podem ser obtidos usando [NemotronH_Omni_Reasoning_V3VideoProcessor](/docs/transformers/main/pt/model_doc/nemotron_h_omni#transformers.NemotronH_Omni_Reasoning_V3VideoProcessor). Veja [NemotronH_Omni_Reasoning_V3Processor.__call__()](/docs/transformers/main/pt/model_doc/molmo2#transformers.Molmo2VideoProcessor.__call__) para detalhes ([NemotronH_Omni_Reasoning_V3Processor](/docs/transformers/main/pt/model_doc/nemotron_h_omni#transformers.NemotronH_Omni_Reasoning_V3Processor) usa [NemotronH_Omni_Reasoning_V3VideoProcessor](/docs/transformers/main/pt/model_doc/nemotron_h_omni#transformers.NemotronH_Omni_Reasoning_V3VideoProcessor) para processar vídeos).

input_features (`torch.Tensor` de forma `(batch_size, num_frames, num_mel_bins)`, *opcional*) : Recursos Mel produzidos pelo processador, codificados e distribuídos nos tokens de espaço reservado de áudio.

input_features_mask (`torch.Tensor` de forma `(batch_size, num_frames)`, *opcional*) : Máscara que marca os quadros mel reais de cada clipe com preenchimento.

attention_mask (`torch.Tensor` de forma `(batch_size, sequence_length)`, *opcional*) : Máscara para evitar a execução de atenção nos índices de tokens de preenchimento. Valores de máscara selecionados em `[0, 1]`:  - 1 para tokens que **não estão mascarados**, - 0 para tokens que **estão mascarados**.  [O que são máscaras de atenção?](../glossary#attention-mask)

position_ids (`torch.LongTensor` de forma `(batch_size, sequence_length)`, *opcional*) : Índices das posições dos tokens de cada sequência de entrada nos embeddings de posição. Selecionados no intervalo `[0, config.n_positions - 1]`.  [O que são IDs de posição?](../glossary#position-ids)

past_key_values (`~cache_utils.Cache`, *opcional*) : hidden-states pré-computados (chaves e valores nos blocos de autoatenção e nos blocos de atenção cruzada) que podem ser usados para acelerar a decodificação sequencial. Isso geralmente consiste nos `past_key_values` retornados pelo modelo em uma etapa anterior da decodificação, quando `use_cache=True` ou `config.use_cache=True`.  Apenas uma instância de [Cache](/docs/transformers/main/pt/internal/generation_utils#transformers.Cache) é permitida como entrada, consulte nosso [guia de kv cache](https://huggingface.co/docs/transformers/en/kv_cache). Se nenhum `past_key_values` for passado, [DynamicCache](/docs/transformers/main/pt/internal/generation_utils#transformers.DynamicCache) será inicializado por padrão.  O modelo sairá no mesmo formato de cache que foi fornecido como entrada.  Se `past_key_values` forem usados, espera-se que o usuário insira apenas `input_ids` não processados (aqueles que não têm seus estados de chave e valor passados para este modelo) com a forma `(batch_size, unprocessed_length)` em vez de todos os `input_ids` com a forma `(batch_size, sequence_length)`.

labels (`torch.LongTensor` de forma `(batch_size, sequence_length)`, *opcional*) : Rótulos para calcular a perda de modelagem de linguagem mascarada. Os índices devem estar em `[0, ..., config.vocab_size]` ou ser -100 (veja a docstring de `input_ids`). Tokens com índices definidos como `-100` são ignorados (mascarados); a perda é calculada apenas para os tokens com rótulos em `[0, ..., config.vocab_size]`.

inputs_embeds (`torch.Tensor` de forma `(batch_size, sequence_length, hidden_size)`, *opcional*) : Opcionalmente, em vez de passar `input_ids`, você pode escolher passar diretamente uma representação incorporada. Isso é útil se você quiser ter mais controle sobre como converter os índices de `input_ids` nos vetores associados do que a matriz de busca de incorporação interna do modelo.

use_cache (`bool`, *opcional*) : Se definido como `True`, os estados de chave-valor de `past_key_values` são retornados e podem ser usados para acelerar a decodificação (veja `past_key_values`).

mm_encoder_outputs (`dict[str, ~modeling_outputs.BaseModelOutputWithPooling]`, *opcional*) : Dicionário em que as chaves são as modalidades suportadas e os valores são as saídas codificadas para essa modalidade. Cada saída codificada é uma tupla que consiste em (`pooler_output`, *opcional*: `last_hidden_states`, *opcional*: `hidden_states`, *opcional*: `attentions`) `pooler_output` de forma `(batch_size, sequence_length, hidden_size)`, *opcional*) é uma sequência de recursos multimodais do codificador mesclados em incorporações de texto.

**Retorna:** [CausalLMOutputWithPast](/docs/transformers/main/pt/main_classes/output#transformers.modeling_outputs.CausalLMOutputWithPast) ou `tuple(torch.Tensor)`

Um [CausalLMOutputWithPast](/docs/transformers/main/pt/main_classes/output#transformers.modeling_outputs.CausalLMOutputWithPast) ou uma tupla de `torch.Tensor` (se `return_dict=False` for passado ou quando `config.return_dict=False`) contendo vários elementos, dependendo da configuração ([NemotronH_Omni_Reasoning_V3_Config](/docs/transformers/main/pt/model_doc/nemotron_h_omni#transformers.NemotronH_Omni_Reasoning_V3_Config)) e das entradas.

O método forward de [NemotronH_Omni_Reasoning_V3](/docs/transformers/main/pt/model_doc/nemotron_h_omni#transformers.NemotronH_Omni_Reasoning_V3) substitui o método especial `__call__`.

Embora a receita para a passagem direta precise ser definida dentro desta função, deve-se chamar a instância de `Module` em seguida, em vez desta, pois a primeira cuida da execução das etapas de pré e pós-processamento, enquanto a segunda as ignora silenciosamente.

- **loss** (`torch.Tensor` de forma `(1,)`, *opcional*, retornado quando `labels` é fornecido) -- Perda de modelagem de linguagem (para previsão do próximo token).
- **logits** (`torch.Tensor` de forma `(batch_size, sequence_length, config.vocab_size)`) -- Pontuações de previsão da cabeça de modelagem de linguagem (pontuações para cada token do vocabulário antes do SoftMax).
- **past_key_values** (`Cache`, *opcional*, retornado quando `use_cache=True` é passado ou quando `config.use_cache=True`) -- Trata-se de uma instância de [Cache](/docs/transformers/main/pt/internal/generation_utils#transformers.Cache). Para mais detalhes, consulte nosso [guia de cache kv](https://huggingface.co/docs/transformers/en/kv_cache).

  Contém estados ocultos pré-computados (chaves e valores nos blocos de autoatenção) que podem ser usados (veja a entrada `past_key_values`) para acelerar a decodificação sequencial.
- **hidden_states** (`tuple(torch.Tensor)`, *opcional*, retornado quando `output_hidden_states=True` é passado ou quando `config.output_hidden_states=True`) -- Tupla de `torch.Tensor` (um para a saída dos embeddings, se o modelo tiver uma camada de embedding, + um para a saída de cada camada) com a forma `(batch_size, sequence_length, hidden_size)`.

  Estados ocultos do modelo na saída de cada camada, além das saídas opcionais do embedding inicial.
- **attentions** (`tuple(torch.Tensor)`, *opcional*, retornado quando `output_attentions=True` é passado ou quando `config.output_attentions=True`) -- Tupla de `torch.Tensor` (um para cada camada) com a forma `(batch_size, num_heads, sequence_length, sequence_length)`.

  Pesos de atenção após o softmax de atenção, usados para calcular a média ponderada nas cabeças de autoatenção.

Exemplo:

```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)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/utils.py#L2581)

**Parâmetros:**

inputs (`torch.Tensor` de forma variável dependendo da modalidade, *opcional*) : A sequência usada como prompt para a geração ou como entradas do modelo para o codificador. Se `None`, o método a inicializa com `bos_token_id` e um tamanho de lote de 1. Para modelos apenas de decodificador, `inputs` deve estar no formato de `input_ids`. Para modelos codificador-decodificador, *inputs* pode representar qualquer um de `input_ids`, `input_values`, `input_features` ou `pixel_values`.

generation_config ([GenerationConfig](/docs/transformers/main/pt/main_classes/text_generation#transformers.GenerationConfig), *opcional*) : A configuração de geração a ser usada como parametrização base para a chamada de geração. Os `**kwargs` passados para generate que correspondam aos atributos de `generation_config` os sobrescreverão. Se `generation_config` não for fornecido, o padrão será usado, que tem a seguinte prioridade de carregamento: 1) do arquivo de modelo `generation_config.json`, se existir; 2) da configuração do modelo. Observe que os parâmetros não especificados herdarão os valores padrão de [GenerationConfig](/docs/transformers/main/pt/main_classes/text_generation#transformers.GenerationConfig), cuja documentação deve ser consultada para parametrizar a geração.

logits_processor (`LogitsProcessorList`, *opcional*) : Processadores de logits personalizados que complementam os processadores de logits padrão criados a partir dos argumentos e da configuração de geração. Se um processador de logits for passado que já foi criado com os argumentos ou uma configuração de geração, um erro será lançado. Este recurso é destinado a usuários avançados.

stopping_criteria (`StoppingCriteriaList`, *opcional*) : Critérios de parada personalizados que complementam os critérios de parada padrão criados a partir dos argumentos e de uma configuração de geração. Se um critério de parada for passado que já foi criado com os argumentos ou com uma configuração de geração, um erro será lançado. Se o seu critério de parada depende da entrada `scores`, certifique-se de passar `return_dict_in_generate=True, output_scores=True` para `generate`. Este recurso é destinado a usuários avançados.

prefix_allowed_tokens_fn (`Callable[[int, torch.Tensor], list[int]]`, *opcional*) : Se fornecida, esta função restringe a busca por feixe apenas aos tokens permitidos em cada etapa. Se não for fornecida, nenhuma restrição é aplicada. Esta função recebe 2 argumentos: o ID do lote `batch_id` e `input_ids`. Ela deve retornar uma lista com os tokens permitidos para a próxima etapa de geração, condicionada ao ID do lote `batch_id` e aos tokens gerados anteriormente `inputs_ids`. Este argumento é útil para geração condicionada ao prefixo, conforme descrito em [Autoregressive Entity Retrieval](https://huggingface.co/papers/2010.00904).

synced_gpus (`bool`, *opcional*) : Se deve continuar executando o loop while até max_length. A menos que seja sobrescrito, este sinalizador será definido como `True` ao usar `FullyShardedDataParallel` ou DeepSpeed ZeRO Stage 3 com múltiplas GPUs, para evitar deadlocks caso uma GPU termine a geração antes das outras. Caso contrário, o valor padrão é `False`.

assistant_model (`PreTrainedModel`, *opcional*) : Um modelo assistente que pode ser usado para acelerar a geração. O modelo assistente deve ter exatamente o mesmo tokenizer. A aceleração é obtida quando a previsão de tokens candidatos com o modelo assistente é muito mais rápida do que executar a geração com o modelo do qual você está chamando generate. Dessa forma, o modelo assistente deve ser muito menor.

streamer (`BaseStreamer`, *opcional*) : objeto Streamer que será usado para transmitir as sequências geradas. Os tokens gerados são passados por `streamer.put(token_ids)` e o streamer é responsável por qualquer processamento adicional.

negative_prompt_ids (`torch.LongTensor` de forma `(batch_size, sequence_length)`, *opcional*) : O prompt negativo necessário para alguns processadores, como o CFG. O tamanho do lote deve corresponder ao tamanho do lote de entrada. Esta é uma funcionalidade experimental, sujeita a alterações na API que podem quebrar a compatibilidade em versões futuras.

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

custom_generate (`str` ou `Callable`, *opcional*) : Um dos seguintes: - `str` (nome do repositório no Hugging Face Hub): executa a função personalizada `generate` definida em `custom_generate/generate.py` nesse repositório, em vez do método padrão `generate`. O repositório substitui completamente a lógica de geração, e o tipo de retorno pode ser diferente. - `str` (caminho local do repositório): o mesmo que acima, mas a partir de um caminho local. Diretórios locais também exigem `trust_remote_code=True`, pois o `custom_generate/generate.py` local é executado. - `Callable`: `generate` executará as etapas habituais de preparação da entrada e, em seguida, chamará a função fornecida para executar o loop de decodificação. Para mais informações, consulte [a documentação](../../generation_strategies#custom-generation-methods).

kwargs (`dict[str, Any]`, *opcional*) : Parametrização ad hoc de `generation_config` e/ou kwargs específicos do modelo adicionais que serão encaminhados para a função `forward` do modelo. Se o modelo for um modelo encoder-decoder, os kwargs específicos do encoder não devem ter prefixo e os kwargs específicos do decoder devem ter o prefixo *decoder_*.

**Retorna:** [ModelOutput](/docs/transformers/main/pt/main_classes/output#transformers.utils.ModelOutput) ou `torch.LongTensor`

Um [ModelOutput](/docs/transformers/main/pt/main_classes/output#transformers.utils.ModelOutput) (se `return_dict_in_generate=True` ou quando `config.return_dict_in_generate=True`) ou um `torch.LongTensor`.

Se o modelo *não* for um modelo encoder-decoder (`model.config.is_encoder_decoder=False`), os tipos possíveis de [ModelOutput](/docs/transformers/main/pt/main_classes/output#transformers.utils.ModelOutput) são:

- [GenerateDecoderOnlyOutput](/docs/transformers/main/pt/internal/generation_utils#transformers.generation.GenerateDecoderOnlyOutput),
- [GenerateBeamDecoderOnlyOutput](/docs/transformers/main/pt/internal/generation_utils#transformers.generation.GenerateBeamDecoderOnlyOutput)

Se o modelo for um modelo encoder-decoder (`model.config.is_encoder_decoder=True`), os tipos possíveis de [ModelOutput](/docs/transformers/main/pt/main_classes/output#transformers.utils.ModelOutput) são:

- [GenerateEncoderDecoderOutput](/docs/transformers/main/pt/internal/generation_utils#transformers.generation.GenerateEncoderDecoderOutput),
- [GenerateBeamEncoderDecoderOutput](/docs/transformers/main/pt/internal/generation_utils#transformers.generation.GenerateBeamEncoderDecoderOutput)

Gera sequências de ids de tokens para modelos com uma cabeça de modelagem de linguagem.

A maioria dos parâmetros de controle de geração é definida em `generation_config`, que, se não for fornecida, será definida como a configuração de geração padrão do modelo. Você pode sobrescrever qualquer `generation_config` passando os parâmetros correspondentes para generate(), por exemplo, `.generate(inputs, num_beams=4, do_sample=True)`.

Para uma visão geral das estratégias de geração e exemplos de código, consulte o [guia a seguir](../generation_strategies).