# NemotronH Omni

NemotronH Omni adalah model penalaran multimodal dari NVIDIA yang memadukan model bahasa hibrida Mamba-Transformer [NemotronH](./nemotron_h) dengan encoder visual [RADIO](./radio) dan encoder suara opsional berbasis Parakeet. Patch gambar (dan video) diproyeksikan melalui menara RADIO dan MLP pixel-shuffle ke ruang embedding model bahasa pada posisi token konteks `<image>` / `<video>`; klip audio diproyeksikan dengan cara yang sama pada posisi `<audio>`. Hasilnya adalah model autoregresif tunggal yang melakukan penalaran secara bersama atas teks, gambar, video, dan suara.

Contoh di bawah ini menunjukkan cara melakukan penalaran pada gambar dan prompt teks dengan [AutoModelForImageTextToText](/docs/transformers/main/id/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)
```

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

**Parameter:**

vision_config (`dict` atau `RadioConfig`, *opsional*) : Konfigurasi untuk encoder visual RADIO. Secara default menggunakan [RadioConfig](/docs/transformers/main/id/model_doc/radio#transformers.RadioConfig) default.

text_config (`dict` atau `NemotronHConfig`, *opsional*) : Konfigurasi untuk model bahasa NemotronH. Secara default menggunakan [NemotronHConfig](/docs/transformers/main/id/model_doc/nemotron_h#transformers.NemotronHConfig) default.

audio_config (`dict` atau `ParakeetEncoderConfig`, *opsional*) : Konfigurasi untuk encoder suara Parakeet opsional. `None` menonaktifkan cabang audio.

force_image_size (`int`, *opsional*) : Resolusi gambar input tetap (dalam piksel) yang diharapkan oleh menara visual.

downsample_ratio (`float`, *opsional*, default 0.5) : Rasio downsample spasial pixel-shuffle yang diterapkan pada fitur visual.

projector_hidden_size (`int`, *opsional*, default 4096) : Ukuran tersembunyi dari proyektor MLP vision-to-LLM.

vision_hidden_size (`int`, *opsional*, default 1280) : Ukuran tersembunyi dari fitur visual RADIO.

video_pruning_rate (`float`, *opsional*, default 0.0) : tingkat pemangkasan token Efficient-Video-Sampling; `0.0` menonaktifkan pemangkasan.

video_temporal_patch_size (`int`, *opsional*, default 2) : Jumlah frame yang digabungkan menjadi satu patch temporal oleh video embedder.

image_token_id (`int`, *opsional*) : ID token yang digunakan sebagai placeholder konteks gambar di `input_ids`.

video_token_id (`int`, *opsional*) : ID token yang digunakan sebagai placeholder konteks video di `input_ids`.

audio_token_id (`int`, *opsional*) : ID token yang digunakan sebagai placeholder konteks audio di `input_ids`.

Ini adalah kelas konfigurasi untuk menyimpan konfigurasi dari Nemotron H OmniModel. Kelas ini digunakan untuk membuat instans model Nemotron H Omni sesuai dengan argumen yang ditentukan, sehingga mendefinisikan arsitektur model. Membuat instans konfigurasi dengan nilai bawaan akan menghasilkan konfigurasi yang serupa dengan konfigurasi dari [nvidia/Nemotron-3-Nano-Omni-30B-A3B-Reasoning-BF16](https://huggingface.co/nvidia/Nemotron-3-Nano-Omni-30B-A3B-Reasoning-BF16)

Objek konfigurasi mewarisi dari [PreTrainedConfig](/docs/transformers/main/id/main_classes/configuration#transformers.PreTrainedConfig) dan dapat digunakan untuk mengontrol keluaran model. Baca dokumentasi dari [PreTrainedConfig](/docs/transformers/main/id/main_classes/configuration#transformers.PreTrainedConfig) untuk informasi lebih lanjut.

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

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

**Parameter:**

do_convert_rgb (`bool`, *kwargs*, *opsional*, defaultnya `True`) : Apakah akan mengonversi gambar ke RGB.

do_resize (`bool`, *kwargs*, *opsional*) : Apakah akan mengubah ukuran gambar.

size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*) : Menjelaskan dimensi input maksimum ke model.

default_to_square (`bool`, *kwargs*, *opsional*, defaultnya `True`) : Apakah secara default menggunakan gambar persegi saat mengubah ukuran, jika size berupa int.

crop_size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*) : Ukuran gambar keluaran setelah menerapkan `center_crop`.

resample (`Annotated[Union[int, PILImageResampling, NoneType], None]`, *kwargs*, defaultnya `3`) : Filter resampling yang digunakan jika mengubah ukuran gambar. Ini bisa berupa salah satu enum `PILImageResampling`. Hanya berdampak jika `do_resize` diatur ke `True`.

do_rescale (`bool`, *kwargs*, *opsional*, defaultnya `True`) : Apakah akan melakukan penskalaan ulang pada gambar.

rescale_factor (`float`, *kwargs*, *opsional*, defaultnya `0.00392156862745098`) : Faktor rescale untuk melakukan rescale pada gambar jika `do_rescale` diatur ke `True`.

do_normalize (`bool`, *kwargs*, *opsional*, defaultnya `True`) : Apakah akan menormalisasi gambar.

image_mean (`Union[float, list[float], tuple[float, ...]]`, *kwargs*, *opsional*, defaultnya `[0.48145466, 0.4578275, 0.40821073]`) : Rata-rata gambar yang digunakan untuk normalisasi. Hanya berpengaruh jika `do_normalize` diatur ke `True`.

image_std (`Union[float, list[float], tuple[float, ...]]`, *kwargs*, *opsional*, defaultnya `[0.26862954, 0.26130258, 0.27577711]`) : Standar deviasi gambar yang digunakan untuk normalisasi. Hanya berpengaruh jika `do_normalize` diatur ke `True`.

do_pad (`bool`, *kwargs*, *opsional*) : Apakah akan melakukan padding pada gambar. Padding dilakukan hingga ukuran terbesar dalam batch atau hingga ukuran persegi tetap per gambar. Strategi padding yang tepat bergantung pada model.

pad_size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*) : Ukuran dalam `{"height": int, "width" int}` untuk melakukan padding pada gambar. Harus lebih besar dari ukuran gambar mana pun yang diberikan untuk pra-pemrosesan. Jika `pad_size` tidak diberikan, gambar akan di-pad hingga tinggi dan lebar terbesar dalam batch. Diterapkan hanya ketika `do_pad=True.`

do_center_crop (`bool`, *kwargs*, *opsional*) : Apakah akan melakukan center crop pada gambar.

data_format (`Union[str, ~image_utils.ChannelDimension]`, *kwargs*, *opsional*) : Hanya `ChannelDimension.FIRST` yang didukung. Ditambahkan untuk kompatibilitas dengan prosesor lambat.

input_data_format (`Union[str, ~image_utils.ChannelDimension]`, *kwargs*, *opsional*) : Format dimensi channel untuk gambar input. Jika tidak disetel, format dimensi channel akan disimpulkan dari gambar input. Bisa berupa salah satu dari: - `"channels_first"` atau `ChannelDimension.FIRST`: gambar dalam format (num_channels, height, width). - `"channels_last"` atau `ChannelDimension.LAST`: gambar dalam format (height, width, num_channels). - `"none"` atau `ChannelDimension.NONE`: gambar dalam format (height, width).

device (`Annotated[Union[str, torch.device, NoneType], None]`, *kwargs*) : Perangkat untuk memproses video. Jika tidak disetel, perangkat akan disimpulkan dari video input.

return_tensors (`Annotated[str | ~utils.generic.TensorType | None, None]`, *kwargs*) : Mengembalikan tensor yang ditumpuk jika disetel ke `'pt'`, selain itu mengembalikan daftar tensor.

disable_grouping (`bool`, *kwargs*, *opsional*) : Apakah akan menonaktifkan pengelompokan gambar berdasarkan ukuran untuk memprosesnya secara individual dan tidak dalam batch. Jika None, akan diset ke True jika gambar berada di CPU, dan False selain itu. Pilihan ini didasarkan pada pengamatan empiris, seperti yang dijelaskan di sini: https://github.com/huggingface/transformers/pull/38157

image_seq_length (`int`, *kwargs*, *opsional*) : Jumlah token gambar yang akan digunakan untuk setiap gambar dalam input. Ditambahkan untuk kompatibilitas mundur, tetapi ini sebaiknya diatur sebagai atribut prosesor pada model-model mendatang.

patch_size (`int`, *kwargs*, *opsional*, default 16) : Panjang sisi, dalam piksel, dari satu patch vision-tower.

downsample_ratio (`float`, *kwargs*, *opsional*, default 0.5) : Rasio downsample spasial pixel-shuffle yang diterapkan oleh model; setiap sisi grid patch adalah kelipatan dari resiprokalnya.

min_num_patches (`int`, *kwargs*, *opsional*, default 1024) : Jumlah minimum patch `patch_size` yang menjadi target resize gambar.

max_num_patches (`int`, *kwargs*, *opsional*, default 13312) : Jumlah maksimum `patch_size` patch yang menjadi target resize gambar; `0` menonaktifkan batas tersebut.

max_model_len (`int`, *kwargs*, *opsional*, default 16384) : Panjang konteks dari model bahasa, yang membatasi anggaran patch untuk gambar dalam satu pemanggilan.

Membangun pemroses gambar 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'>)
```

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

**Parameter:**

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*, *opsional*) : Apakah akan mengkonversi gambar ke RGB.

do_resize (`bool`, *kwargs*, *opsional*) : Apakah akan mengubah ukuran gambar.

size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*) : Menjelaskan dimensi input maksimum ke model.

default_to_square (`bool`, *kwargs*, *opsional*) : Apakah secara default menggunakan gambar persegi saat mengubah ukuran, jika size berupa int.

crop_size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*) : Ukuran gambar keluaran setelah menerapkan `center_crop`.

resample (`Annotated[Union[int, PILImageResampling, NoneType], None]`, *kwargs*) : Filter resampling yang digunakan saat mengubah ukuran gambar. Nilai ini dapat berupa salah satu enum `PILImageResampling`. Hanya berpengaruh jika `do_resize` diatur ke `True`.

do_rescale (`bool`, *kwargs*, *opsional*) : Apakah akan melakukan penskalaan ulang pada gambar.

rescale_factor (`float`, *kwargs*, *opsional*) : Faktor penskalaan ulang untuk menskalakan ulang gambar jika `do_rescale` diatur ke `True`.

do_normalize (`bool`, *kwargs*, *opsional*) : Apakah akan menormalisasi gambar.

image_mean (`Union[float, list[float], tuple[float, ...]]`, *kwargs*, *opsional*) : Rata-rata gambar yang digunakan untuk normalisasi. Hanya berpengaruh jika `do_normalize` diatur ke `True`.

image_std (`Union[float, list[float], tuple[float, ...]]`, *kwargs*, *opsional*) : Standar deviasi gambar yang digunakan untuk normalisasi. Hanya berpengaruh jika `do_normalize` diatur ke `True`.

do_pad (`bool`, *kwargs*, *opsional*) : Apakah akan melakukan padding pada gambar. Padding dilakukan hingga ukuran terbesar dalam batch atau hingga ukuran persegi tetap per gambar. Strategi padding yang tepat bergantung pada model.

pad_size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*) : Ukuran dalam `{"height": int, "width" int}` untuk melakukan padding pada gambar. Harus lebih besar dari ukuran gambar mana pun yang diberikan untuk pra-pemrosesan. Jika `pad_size` tidak diberikan, gambar akan di-pad hingga tinggi dan lebar terbesar dalam batch. Diterapkan hanya ketika `do_pad=True.`

do_center_crop (`bool`, *kwargs*, *opsional*) : Apakah akan melakukan center crop pada gambar.

data_format (`Union[str, ~image_utils.ChannelDimension]`, *kwargs*, *opsional*) : Hanya `ChannelDimension.FIRST` yang didukung. Ditambahkan untuk kompatibilitas dengan prosesor lambat.

input_data_format (`Union[str, ~image_utils.ChannelDimension]`, *kwargs*, *opsional*) : Format dimensi channel untuk gambar input. Jika tidak disetel, format dimensi channel akan disimpulkan dari gambar input. Bisa berupa salah satu dari: - `"channels_first"` atau `ChannelDimension.FIRST`: gambar dalam format (num_channels, height, width). - `"channels_last"` atau `ChannelDimension.LAST`: gambar dalam format (height, width, num_channels). - `"none"` atau `ChannelDimension.NONE`: gambar dalam format (height, width).

device (`Annotated[Union[str, torch.device, NoneType], None]`, *kwargs*) : Perangkat untuk memproses video. Jika tidak disetel, perangkat akan disimpulkan dari video input.

return_tensors (`Annotated[str | ~utils.generic.TensorType | None, None]`, *kwargs*) : Mengembalikan tensor yang ditumpuk jika disetel ke `'pt'`, selain itu mengembalikan daftar tensor.

disable_grouping (`bool`, *kwargs*, *opsional*) : Apakah akan menonaktifkan pengelompokan gambar berdasarkan ukuran untuk memprosesnya secara individual dan tidak dalam batch. Jika None, akan diset ke True jika gambar berada di CPU, dan False selain itu. Pilihan ini didasarkan pada pengamatan empiris, seperti yang dijelaskan di sini: https://github.com/huggingface/transformers/pull/38157

image_seq_length (`int`, *kwargs*, *opsional*) : Jumlah token gambar yang akan digunakan untuk setiap gambar dalam input. Ditambahkan untuk kompatibilitas mundur, tetapi ini sebaiknya diatur sebagai atribut prosesor pada model-model mendatang.

patch_size (`int`, *kwargs*, *opsional*, default 16) : Panjang sisi, dalam piksel, dari satu patch vision-tower.

downsample_ratio (`float`, *kwargs*, *opsional*, default 0.5) : Rasio downsample spasial pixel-shuffle yang diterapkan oleh model; setiap sisi grid patch adalah kelipatan dari resiprokalnya.

min_num_patches (`int`, *kwargs*, *opsional*, default 1024) : Jumlah minimum patch `patch_size` yang menjadi target resize gambar.

max_num_patches (`int`, *kwargs*, *opsional*, default 13312) : Jumlah maksimum `patch_size` patch yang menjadi target resize gambar; `0` menonaktifkan batas tersebut.

max_model_len (`int`, *kwargs*, *opsional*, default 16384) : Panjang konteks dari model bahasa, yang membatasi anggaran patch untuk gambar dalam satu pemanggilan.

**Mengembalikan:** `~image_processing_base.BatchFeature`

- **data** (`dict`) -- Dictionary berisi list/array/tensor yang dikembalikan oleh metode __call__ ('pixel_values', dll.).
- **tensor_type** (`Union[None, str, TensorType]`, *opsional*) -- Anda dapat memberikan tensor_type di sini untuk mengonversi daftar bilangan bulat menjadi Tensor PyTorch/Numpy saat inisialisasi.

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

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

**Parameter:**

- ****kwargs** (`NemotronH_Omni_Reasoning_V3VideoProcessorInitKwargs`, *opsional*) : Opsi pemrosesan tambahan untuk setiap modalitas (teks, gambar, video, audio). Parameter spesifik model tercantum di atas; lihat kelas TypedDict untuk daftar lengkap argumen yang didukung.

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

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

**Parameter:**

image_processor (`NemotronH_Omni_Reasoning_V3ImageProcessor`) : Prosesor gambar adalah input yang wajib.

video_processor (`NemotronH_Omni_Reasoning_V3VideoProcessor`) : Prosesor video adalah input yang wajib.

tokenizer (`tokenizer_class`) : Tokenizer adalah input yang wajib.

feature_extractor (`feature_extractor_class`) : Feature extractor adalah input yang wajib.

chat_template (`str`) : Template Jinja untuk mengonversi daftar pesan dalam chat menjadi string yang dapat ditokenisasi.

audio_sampling_rate (`int`, *opsional*, default 16000) : Laju sampling, dalam Hz, yang diharapkan untuk waveform audio.

audio_subsampling_factor (`int`, *opsional*, default 8) : Faktor yang digunakan oleh sound encoder untuk melakukan subsampling pada frame mel, yang dipakai untuk menentukan ukuran run placeholder audio.

audio_hop_length (`int`, *opsional*, default 160) : Panjang hop, dalam sampel, antara frame mel yang berurutan.

video_temporal_patch_dim (`int`, *opsional*, default 2) : Jumlah frame yang digabungkan menjadi satu patch temporal oleh video embedder model.

Membangun NemotronH_Omni_Reasoning_V3Processor yang membungkus image processor, video processor, tokenizer, dan feature extractor menjadi satu processor.

[NemotronH_Omni_Reasoning_V3Processor](/docs/transformers/main/id/model_doc/nemotron_h_omni#transformers.NemotronH_Omni_Reasoning_V3Processor) menyediakan semua fungsionalitas dari [NemotronH_Omni_Reasoning_V3ImageProcessor](/docs/transformers/main/id/model_doc/nemotron_h_omni#transformers.NemotronH_Omni_Reasoning_V3ImageProcessor), [NemotronH_Omni_Reasoning_V3VideoProcessor](/docs/transformers/main/id/model_doc/nemotron_h_omni#transformers.NemotronH_Omni_Reasoning_V3VideoProcessor), `tokenizer_class`, dan `feature_extractor_class`. Lihat [~NemotronH_Omni_Reasoning_V3ImageProcessor](/docs/transformers/main/id/model_doc/nemotron_h_omni#transformers.NemotronH_Omni_Reasoning_V3ImageProcessor), [~NemotronH_Omni_Reasoning_V3VideoProcessor](/docs/transformers/main/id/model_doc/nemotron_h_omni#transformers.NemotronH_Omni_Reasoning_V3VideoProcessor), `~tokenizer_class`, dan `~feature_extractor_class` untuk informasi lebih lanjut.

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

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

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

Meneruskan ke [batch_decode()](/docs/transformers/main/id/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.batch_decode) tokenizer.

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

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

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

Meneruskan ke [decode()](/docs/transformers/main/id/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.decode) 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)
```

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

Decode id token yang dihasilkan model menjadi teks.

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

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

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

Perluas `<video>` menjadi satu chunk `<img>...</img>` per temporal patch (tubelet).

Setiap chunk diberi label dengan timestamp dari frame yang dikemasnya, digabungkan dengan " and " ("Frame" untuk frame pertama dalam tubelet, "frame" untuk sisanya). Tokenizer tidak memiliki token `<video>` yang sebenarnya, sehingga chunk menggunakan token gambar; model membedakan gambar dari video berdasarkan argumen `pixel_values_*` yang diteruskan.

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

[Sumber](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'>)
```

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

**Parameter:**

input_ids (`torch.LongTensor` dengan bentuk `(batch_size, sequence_length)`, *opsional*) : Indeks token dari urutan input dalam kosakata. Padding akan diabaikan secara default. Indeks dapat diperoleh menggunakan [AutoTokenizer](/docs/transformers/main/id/model_doc/auto#transformers.AutoTokenizer). Lihat [PreTrainedTokenizer.encode()](/docs/transformers/main/id/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) dan [PreTrainedTokenizer.__call__()](/docs/transformers/main/id/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) untuk detailnya. [Apa itu input IDs?](../glossary#input-ids)

pixel_values (`torch.Tensor` dengan bentuk `(total_patches, num_channels * patch_size**2)`, *opsional*) : Patch yang telah diratakan dari semua gambar, digabungkan, sebagaimana dikembalikan oleh pemroses gambar.

image_grid_hw (`torch.LongTensor` dengan bentuk `(num_images, 2)`, *opsional*) : Grid patch `(height, width)` untuk setiap gambar dalam `pixel_values`.

pixel_values_videos (`torch.Tensor` dengan bentuk `(batch_size, num_frames, num_channels, frame_size, frame_size)`, *opsional*) : Tensor yang sesuai dengan video input. Nilai piksel untuk video dapat diperoleh menggunakan [NemotronH_Omni_Reasoning_V3VideoProcessor](/docs/transformers/main/id/model_doc/nemotron_h_omni#transformers.NemotronH_Omni_Reasoning_V3VideoProcessor). Lihat [NemotronH_Omni_Reasoning_V3VideoProcessor.__call__()](/docs/transformers/main/id/model_doc/molmo2#transformers.Molmo2VideoProcessor.__call__) untuk detailnya ([NemotronH_Omni_Reasoning_V3Processor](/docs/transformers/main/id/model_doc/nemotron_h_omni#transformers.NemotronH_Omni_Reasoning_V3Processor) menggunakan [NemotronH_Omni_Reasoning_V3VideoProcessor](/docs/transformers/main/id/model_doc/nemotron_h_omni#transformers.NemotronH_Omni_Reasoning_V3VideoProcessor) untuk memproses video).

input_features (`torch.Tensor` dengan bentuk `(batch_size, num_frames, num_mel_bins)`, *opsional*) : Fitur Mel yang dihasilkan oleh processor, dikodekan dan disebar ke token placeholder audio.

input_features_mask (`torch.Tensor` dengan bentuk `(batch_size, num_frames)`, *opsional*) : Mask yang menandai frame mel asli dari setiap klip yang di-pad.

attention_mask (`torch.Tensor` dengan bentuk `(batch_size, sequence_length)`, *opsional*) : Mask untuk menghindari pelaksanaan attention pada indeks token padding. Nilai mask dipilih dalam `[0, 1]`:  - 1 untuk token yang **tidak di-mask**, - 0 untuk token yang **di-mask**.  [Apa itu attention masks?](../glossary#attention-mask)

position_ids (`torch.LongTensor` dengan bentuk `(batch_size, sequence_length)`, *opsional*) : Indeks posisi token dari setiap urutan input dalam embedding posisi. Dipilih dalam rentang `[0, config.n_positions - 1]`.  [Apa itu position ID?](../glossary#position-ids)

past_key_values (`~cache_utils.Cache`, *opsional*) : Hidden-states yang telah dihitung sebelumnya (key dan values di blok self-attention dan di blok cross-attention) yang dapat digunakan untuk mempercepat decoding berurutan. Ini biasanya terdiri dari `past_key_values` yang dikembalikan oleh model pada tahap decoding sebelumnya, ketika `use_cache=True` atau `config.use_cache=True`. Hanya instance [Cache](/docs/transformers/main/id/internal/generation_utils#transformers.Cache) yang diizinkan sebagai input, lihat [panduan kv cache](https://huggingface.co/docs/transformers/en/kv_cache) kami. Jika tidak ada `past_key_values` yang diteruskan, [DynamicCache](/docs/transformers/main/id/internal/generation_utils#transformers.DynamicCache) akan diinisialisasi secara default. Model akan mengoutput format cache yang sama dengan yang diberikan sebagai input. Jika `past_key_values` digunakan, pengguna diharapkan untuk hanya menginput `input_ids` yang belum diproses (yang tidak memiliki state past key value mereka diberikan ke model ini) dengan bentuk `(batch_size, unprocessed_length)` alih-alih semua `input_ids` dengan bentuk `(batch_size, sequence_length)`.

labels (`torch.LongTensor` dengan bentuk `(batch_size, sequence_length)`, *opsional*) : Label untuk menghitung kerugian pemodelan bahasa yang disamarkan. Indeks harus berada di `[0, ..., config.vocab_size]` atau -100 (lihat docstring `input_ids`). Token dengan indeks yang disetel ke `-100` diabaikan (disamarkan), kerugian hanya dihitung untuk token dengan label di `[0, ..., config.vocab_size]`.

inputs_embeds (`torch.Tensor` dengan bentuk `(batch_size, sequence_length, hidden_size)`, *opsional*) : Secara opsional, alih-alih meneruskan `input_ids`, Anda dapat memilih untuk langsung meneruskan representasi tertanam. Ini berguna jika Anda ingin lebih banyak kendali atas cara mengonversi indeks `input_ids` menjadi vektor terkait daripada matriks pencarian penanaman internal model.

use_cache (`bool`, *opsional*) : Jika diatur ke `True`, state kunci-nilai `past_key_values` akan dikembalikan dan dapat digunakan untuk mempercepat decoding (lihat `past_key_values`).

mm_encoder_outputs (`dict[str, ~modeling_outputs.BaseModelOutputWithPooling]`, *opsional*) : Dict di mana kuncinya adalah modalitas yang didukung dan nilainya adalah output terenkod untuk modalitas tersebut. Setiap output terenkod adalah tuple yang terdiri dari (`pooler_output`, *opsional*: `last_hidden_states`, *opsional*: `hidden_states`, *opsional*: `attentions`) `pooler_output` dengan bentuk `(batch_size, sequence_length, hidden_size)`, *opsional*) adalah rangkaian fitur multimodal dari encoder yang digabungkan ke dalam embedding teks.

**Mengembalikan:** [CausalLMOutputWithPast](/docs/transformers/main/id/main_classes/output#transformers.modeling_outputs.CausalLMOutputWithPast) atau `tuple(torch.Tensor)`

A [CausalLMOutputWithPast](/docs/transformers/main/id/main_classes/output#transformers.modeling_outputs.CausalLMOutputWithPast) atau tuple dari `torch.Tensor` (jika `return_dict=False` dilewatkan atau ketika `config.return_dict=False`) yang terdiri dari berbagai elemen tergantung pada konfigurasi ([NemotronH_Omni_Reasoning_V3_Config](/docs/transformers/main/id/model_doc/nemotron_h_omni#transformers.NemotronH_Omni_Reasoning_V3_Config)) dan input.

Metode forward [NemotronH_Omni_Reasoning_V3](/docs/transformers/main/id/model_doc/nemotron_h_omni#transformers.NemotronH_Omni_Reasoning_V3) menimpa metode khusus `__call__`.

Meskipun resep untuk forward pass perlu didefinisikan di dalam fungsi ini, sebaiknya panggil instance `Module` setelahnya alih-alih fungsi ini, karena yang pertama menangani langkah-langkah pra-pemrosesan dan pasca-pemrosesan, sedangkan yang kedua mengabaikannya secara diam-diam.

- **loss** (`torch.Tensor` dengan bentuk `(1,)`, *opsional*, dikembalikan saat `labels` disediakan) -- Loss pemodelan bahasa (untuk prediksi token berikutnya).
- **logits** (`torch.Tensor` dengan bentuk `(batch_size, sequence_length, config.vocab_size)`) -- Skor prediksi dari kepala pemodelan bahasa (skor untuk setiap token kosakata sebelum SoftMax).
- **past_key_values** (`Cache`, *opsional*, dikembalikan saat `use_cache=True` dilewatkan atau saat `config.use_cache=True`) -- Ini adalah instance [Cache](/docs/transformers/main/id/internal/generation_utils#transformers.Cache). Untuk detail lebih lanjut, lihat [panduan kv cache](https://huggingface.co/docs/transformers/en/kv_cache) kami.

  Berisi hidden-states yang telah dihitung sebelumnya (key dan values di blok self-attention) yang dapat digunakan (lihat input `past_key_values`) untuk mempercepat decoding berurutan.
- **hidden_states** (`tuple(torch.Tensor)`, *opsional*, dikembalikan saat `output_hidden_states=True` dilewatkan atau saat `config.output_hidden_states=True`) -- Tuple dari `torch.Tensor` (satu untuk output dari embeddings, jika model memiliki lapisan embedding, + satu untuk output dari setiap lapisan) dengan bentuk `(batch_size, sequence_length, hidden_size)`.

  Hidden-states model pada output setiap layer ditambah output embedding awal yang opsional.
- **attentions** (`tuple(torch.Tensor)`, *opsional*, dikembalikan ketika `output_attentions=True` dilewatkan atau ketika `config.output_attentions=True`) -- Tuple dari `torch.Tensor` (satu untuk setiap layer) dengan bentuk `(batch_size, num_heads, sequence_length, sequence_length)`.

  Bobot perhatian setelah softmax perhatian, digunakan untuk menghitung rata-rata berbobot di kepala self-attention.

Contoh:

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

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

**Parameter:**

inputs (`torch.Tensor` dengan bentuk yang bervariasi tergantung pada modalitas, *opsional*) : Urutan yang digunakan sebagai prompt untuk generasi atau sebagai input model ke encoder. Jika `None`, metode ini menginisialisasinya dengan `bos_token_id` dan ukuran batch 1. Untuk model decoder-only, `inputs` harus dalam format `input_ids`. Untuk model encoder-decoder, *inputs* dapat mewakili salah satu dari `input_ids`, `input_values`, `input_features`, atau `pixel_values`.

generation_config ([GenerationConfig](/docs/transformers/main/id/main_classes/text_generation#transformers.GenerationConfig), *opsional*) : Konfigurasi generasi yang akan digunakan sebagai parametrisasi dasar untuk panggilan generasi. `**kwargs` yang diteruskan ke generate dan cocok dengan atribut dari `generation_config` akan menimpanya. Jika `generation_config` tidak disediakan, nilai default akan digunakan, yang memiliki prioritas pemuatan sebagai berikut: 1) dari file model `generation_config.json`, jika ada; 2) dari konfigurasi model. Harap diperhatikan bahwa parameter yang tidak ditentukan akan mewarisi nilai default dari [GenerationConfig](/docs/transformers/main/id/main_classes/text_generation#transformers.GenerationConfig), dan dokumentasinya harus diperiksa untuk memparametrisasi generasi.

logits_processor (`LogitsProcessorList`, *opsional*) : Prosesor logits kustom yang melengkapi prosesor logits bawaan yang dibangun dari argumen dan konfigurasi generasi. Jika prosesor logits yang sudah dibuat dengan argumen atau konfigurasi generasi diteruskan, sebuah error akan dilempar. Fitur ini ditujukan untuk pengguna tingkat lanjut.

stopping_criteria (`StoppingCriteriaList`, *opsional*) : Kriteria penghentian kustom yang melengkapi kriteria penghentian bawaan yang dibangun dari argumen dan konfigurasi generasi. Jika kriteria penghentian yang sudah dibuat dengan argumen atau konfigurasi generasi diteruskan, sebuah error akan dilempar. Jika kriteria penghentian Anda bergantung pada input `scores`, pastikan Anda meneruskan `return_dict_in_generate=True, output_scores=True` ke `generate`. Fitur ini ditujukan untuk pengguna tingkat lanjut.

prefix_allowed_tokens_fn (`Callable[[int, torch.Tensor], list[int]]`, *opsional*) : Jika disediakan, fungsi ini membatasi beam search hanya pada token yang diizinkan di setiap langkah. Jika tidak disediakan, tidak ada batasan yang diterapkan. Fungsi ini mengambil 2 argumen: ID batch `batch_id` dan `input_ids`. Fungsi ini harus mengembalikan daftar token yang diizinkan untuk langkah generasi berikutnya yang dikondisikan pada ID batch `batch_id` dan token yang sebelumnya dihasilkan `inputs_ids`. Argumen ini berguna untuk generasi yang dibatasi berdasarkan prefiks, seperti yang dijelaskan dalam [Autoregressive Entity Retrieval](https://huggingface.co/papers/2010.00904).

synced_gpus (`bool`, *opsional*) : Apakah akan terus menjalankan loop while hingga max_length. Kecuali ditimpa, flag ini akan disetel ke `True` jika menggunakan `FullyShardedDataParallel` atau DeepSpeed ZeRO Stage 3 dengan beberapa GPU untuk menghindari deadlocking jika satu GPU selesai menghasilkan sebelum GPU lainnya. Jika tidak, defaultnya adalah `False`.

assistant_model (`PreTrainedModel`, *opsional*) : Model asisten yang dapat digunakan untuk mempercepat generasi. Model asisten harus memiliki tokenizer yang persis sama. Percepatan tercapai ketika memprediksi token kandidat dengan model asisten jauh lebih cepat daripada menjalankan generasi dengan model yang Anda panggil generate dari. Oleh karena itu, model asisten harus jauh lebih kecil.

streamer (`BaseStreamer`, *opsional*) : Objek Streamer yang akan digunakan untuk streaming urutan yang dihasilkan. Token yang dihasilkan diteruskan melalui `streamer.put(token_ids)` dan streamer bertanggung jawab untuk pemrosesan lebih lanjut.

negative_prompt_ids (`torch.LongTensor` dengan bentuk `(batch_size, sequence_length)`, *opsional*) : Prompt negatif yang diperlukan untuk beberapa prosesor seperti CFG. Ukuran batch harus sesuai dengan ukuran batch input. Ini adalah fitur eksperimental, yang dapat mengalami perubahan API yang merusak (breaking changes) di versi mendatang.

negative_prompt_attention_mask (`torch.LongTensor` dengan bentuk `(batch_size, sequence_length)`, *opsional*) : Attention_mask untuk `negative_prompt_ids`.

custom_generate (`str` atau `Callable`, *opsional*) : Salah satu dari berikut: - `str` (nama repositori Hugging Face Hub): menjalankan fungsi `generate` kustom yang didefinisikan di `custom_generate/generate.py` pada repositori tersebut, bukan metode `generate` standar. Repositori ini sepenuhnya menggantikan logika generasi, dan tipe pengembalian dapat berbeda. - `str` (jalur repositori lokal): sama seperti di atas tetapi dari jalur lokal. Direktori lokal juga memerlukan `trust_remote_code=True` karena `custom_generate/generate.py` lokal akan dieksekusi. - `Callable`: `generate` akan melakukan langkah-langkah persiapan input yang biasa, lalu memanggil callable yang diberikan untuk menjalankan loop decoding. Untuk informasi lebih lanjut, lihat [dokumentasinya](../../generation_strategies#custom-generation-methods).

kwargs (`dict[str, Any]`, *opsional*) : Parametrisasi ad hoc untuk `generation_config` dan/atau kwargs spesifik model tambahan yang akan diteruskan ke fungsi `forward` dari model. Jika model adalah model encoder-decoder, kwargs spesifik encoder tidak boleh diberi awalan dan kwargs spesifik decoder harus diberi awalan *decoder_*.

**Mengembalikan:** [ModelOutput](/docs/transformers/main/id/main_classes/output#transformers.utils.ModelOutput) atau `torch.LongTensor`

[ModelOutput](/docs/transformers/main/id/main_classes/output#transformers.utils.ModelOutput) (jika `return_dict_in_generate=True` atau ketika `config.return_dict_in_generate=True`) atau `torch.LongTensor`.

Jika model *bukan* model encoder-decoder (`model.config.is_encoder_decoder=False`), tipe [ModelOutput](/docs/transformers/main/id/main_classes/output#transformers.utils.ModelOutput) yang mungkin adalah:

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

Jika model adalah model encoder-decoder (`model.config.is_encoder_decoder=True`), tipe [ModelOutput](/docs/transformers/main/id/main_classes/output#transformers.utils.ModelOutput) yang mungkin adalah:

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

Membuat rangkaian id token untuk model dengan kepala pemodelan bahasa.

Sebagian besar parameter pengendali generasi diatur di `generation_config` yang, jika tidak diteruskan, akan disetel ke konfigurasi generasi default model. Anda dapat menimpa `generation_config` mana pun dengan meneruskan parameter yang sesuai ke generate(), misalnya `.generate(inputs, num_beams=4, do_sample=True)`.

Untuk ringkasan strategi generasi dan contoh kode, lihat [panduan berikut](../generation_strategies).