# NemotronH Omni

NemotronH Omni est un modèle de raisonnement multimodal d’NVIDIA qui associe le modèle de langage hybride Mamba-Transformer [NemotronH](./nemotron_h) à un encodeur visuel [RADIO](./radio) et à un encodeur audio optionnel basé sur Parakeet. Les patches d’image (et de vidéo) sont projetés via une tour RADIO et un MLP pixel-shuffle dans l’espace d’embedding du modèle de langage, aux positions des jetons de contexte `<image>` / `<video>` ; les extraits audio sont projetés de la même manière aux positions `<audio>`. Le résultat est un modèle autorégressif unique capable de raisonner conjointement sur le texte, les images, la vidéo et le son.

L'exemple ci-dessous montre comment raisonner sur une image et un prompt de texte avec [AutoModelForImageTextToText](/docs/transformers/v5.23.0/fr/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)
```

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

**Paramètres :**

vision_config (`dict` ou `RadioConfig`, *facultatif*) : Configuration pour l'encodeur visuel RADIO. Par défaut, une [RadioConfig](/docs/transformers/v5.23.0/fr/model_doc/radio#transformers.RadioConfig) par défaut est utilisée.

text_config (`dict` ou `NemotronHConfig`, *facultatif*) : Configuration du modèle de langage NemotronH. Par défaut, une [NemotronHConfig](/docs/transformers/v5.23.0/fr/model_doc/nemotron_h#transformers.NemotronHConfig) par défaut est utilisée.

audio_config (`dict` ou `ParakeetEncoderConfig`, *facultatif*) : Configuration pour l'encodeur de son Parakeet facultatif. `None` désactive la branche audio.

force_image_size (`int`, *facultatif*) : Résolution d'image d'entrée fixe (en pixels) attendue par la tour visuelle.

downsample_ratio (`float`, *facultatif*, valeur par défaut 0,5) : Taux de sous-échantillonnage spatial par pixel-shuffle appliqué aux caractéristiques visuelles.

projector_hidden_size (`int`, *facultatif*, valeur par défaut : 4096) : Taille cachée du projecteur MLP de la vision vers le LLM.

vision_hidden_size (`int`, *facultatif*, valeur par défaut 1280) : Taille cachée des fonctionnalités visuelles de RADIO.

video_pruning_rate (`float`, *facultatif*, valeur par défaut 0.0) : taux de suppression de jetons pour Efficient-Video-Sampling ; `0.0` désactive la suppression.

video_temporal_patch_size (`int`, *facultatif*, valeur par défaut : 2) : Nombre d'images regroupées en un seul patch temporel par l'encodeur vidéo.

image_token_id (`int`, *facultatif*) : Identifiant de jeton utilisé comme espace réservé de contexte d'image dans `input_ids`.

video_token_id (`int`, *facultatif*) : Identifiant de jeton utilisé comme espace réservé de contexte vidéo dans `input_ids`.

audio_token_id (`int`, *facultatif*) : Identifiant de jeton utilisé comme espace réservé de contexte audio dans `input_ids`.

Il s'agit de la classe de configuration destinée à stocker la configuration d'un modèle Nemotron H OmniModel. Elle est utilisée pour instancier un modèle Nemotron H Omni en fonction des arguments spécifiés, en définissant l'architecture du modèle. L'instanciation d'une configuration avec les valeurs par défaut produira une configuration similaire à celle de [nvidia/Nemotron-3-Nano-Omni-30B-A3B-Reasoning-BF16](https://huggingface.co/nvidia/Nemotron-3-Nano-Omni-30B-A3B-Reasoning-BF16)

Les objets de configuration héritent de [PreTrainedConfig](/docs/transformers/v5.23.0/fr/main_classes/configuration#transformers.PreTrainedConfig) et peuvent être utilisés pour contrôler les sorties du modèle. Consultez la documentation de [PreTrainedConfig](/docs/transformers/v5.23.0/fr/main_classes/configuration#transformers.PreTrainedConfig) pour plus d’informations.

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

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

**Paramètres :**

do_convert_rgb (`bool`, *kwargs*, *facultatif*, valeur par défaut `True`) : Indique s'il faut convertir l'image en RGB.

do_resize (`bool`, *kwargs*, *facultatif*) : Indique s'il faut redimensionner l'image.

size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*) : Décrit les dimensions d'entrée maximales du modèle.

default_to_square (`bool`, *kwargs*, *facultatif*, valeur par défaut `True`) : Indique s'il faut par défaut redimensionner l'image en un carré si la taille est un entier.

crop_size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*) : Taille de l'image de sortie après application de `center_crop`.

resample (`Annotated[Union[int, PILImageResampling, NoneType], None]`, *kwargs*, par défaut `3`) : Filtre de rééchantillonnage à utiliser lors du redimensionnement de l'image. Il peut s'agir de l'une des valeurs de l'énumération `PILImageResampling`. N'a un effet que si `do_resize` est défini sur `True`.

do_rescale (`bool`, *kwargs*, *facultatif*, valeur par défaut `True`) : Indique s'il faut rééchelonner l'image.

rescale_factor (`float`, *kwargs*, *facultatif*, valeur par défaut `0.00392156862745098`) : Facteur de remise à l'échelle appliqué à l'image si `do_rescale` est défini sur `True`.

do_normalize (`bool`, *kwargs*, *facultatif*, valeur par défaut `True`) : Indique s'il faut normaliser l'image.

image_mean (`Union[float, list[float], tuple[float, ...]]`, *kwargs*, *facultatif*, valeur par défaut `[0.48145466, 0.4578275, 0.40821073]`) : Moyenne de l'image à utiliser pour la normalisation. N'a un effet que si `do_normalize` est défini sur `True`.

image_std (`Union[float, list[float], tuple[float, ...]]`, *kwargs*, *facultatif*, valeur par défaut `[0.26862954, 0.26130258, 0.27577711]`) : Écart-type de l'image à utiliser pour la normalisation. N'a un effet que si `do_normalize` est défini sur `True`.

do_pad (`bool`, *kwargs*, *facultatif*) : Indique s'il faut ajouter un rembourrage à l'image. Le rembourrage est effectué soit jusqu'à la plus grande taille du lot, soit jusqu'à une taille carrée fixe par image. La stratégie de rembourrage exacte dépend du modèle.

pad_size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*) : La taille au format `{"height": int, "width" int}` à laquelle rembourrer les images. Elle doit être supérieure à la taille de n'importe quelle image fournie pour le prétraitement. Si `pad_size` n'est pas fourni, les images seront rembourrées à la hauteur et à la largeur maximales du lot. Appliqué uniquement lorsque `do_pad=True.`

do_center_crop (`bool`, *kwargs*, *facultatif*) : Indique s'il faut effectuer un recadrage centré de l'image.

data_format (`Union[str, ~image_utils.ChannelDimension]`, *kwargs*, *facultatif*) : Seul `ChannelDimension.FIRST` est pris en charge. Ajouté pour assurer la compatibilité avec les processeurs lents.

input_data_format (`Union[str, ~image_utils.ChannelDimension]`, *kwargs*, *facultatif*) : Le format de la dimension des canaux pour l'image d'entrée. Si non défini, le format de la dimension des canaux est déduit de l'image d'entrée. Peut être l'un des éléments suivants : - `"channels_first"` ou `ChannelDimension.FIRST` : image au format (num_channels, height, width). - `"channels_last"` ou `ChannelDimension.LAST` : image au format (height, width, num_channels). - `"none"` ou `ChannelDimension.NONE` : image au format (height, width).

device (`Annotated[Union[str, torch.device, NoneType], None]`, *kwargs*) : L'appareil sur lequel traiter les vidéos. Si non défini, l'appareil est déduit des vidéos d'entrée.

return_tensors (`Annotated[str | ~utils.generic.TensorType | None, None]`, *kwargs*) : Renvoie des tenseurs empilés si la valeur est `'pt'`, sinon renvoie une liste de tenseurs.

disable_grouping (`bool`, *kwargs*, *facultatif*) : Indique s'il faut désactiver le regroupement des images par taille afin de les traiter individuellement plutôt que par lots. Si la valeur est None, elle sera définie sur True si les images sont sur CPU, et sur False dans le cas contraire. Ce choix repose sur des observations empiriques, comme détaillé ici : https://github.com/huggingface/transformers/pull/38157

image_seq_length (`int`, *kwargs*, *facultatif*) : Le nombre de jetons d'image à utiliser pour chaque image de l'entrée. Ajouté pour la compatibilité ascendante, mais cela devrait être défini comme un attribut du processeur dans les futurs modèles.

patch_size (`int`, *kwargs*, *facultatif*, valeur par défaut 16) : Côté, en pixels, d'un patch de la tour visuelle.

downsample_ratio (`float`, *kwargs*, *facultatif*, valeur par défaut 0,5) : Ratio de sous-échantillonnage spatial par pixel-shuffle appliqué par le modèle ; chaque côté de la grille de patches est un multiple de sa réciproque.

min_num_patches (`int`, *kwargs*, *facultatif*, valeur par défaut 1024) : Nombre minimal de patches de `patch_size` vers lesquels une image est redimensionnée.

max_num_patches (`int`, *kwargs*, *facultatif*, valeur par défaut 13312) : Nombre maximal de patches de taille `patch_size` vers lesquels une image est redimensionnée ; `0` désactive cette limite.

max_model_len (`int`, *kwargs*, *facultatif*, valeur par défaut 16384) : Longueur de contexte du modèle de langage, qui limite le budget de patches des images dans un seul appel.

Construit un processeur d’images NemotronH_Omni_Reasoning_V3ImageProcessor.

#### prétraiter[[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'>)
```

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

**Paramètres :**

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*, *facultatif*) : Indique s'il faut convertir l'image en RGB.

do_resize (`bool`, *kwargs*, *facultatif*) : Indique s'il faut redimensionner l'image.

size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*) : Décrit les dimensions d'entrée maximales du modèle.

default_to_square (`bool`, *kwargs*, *facultatif*) : Indique s'il faut par défaut redimensionner l'image en un carré lorsque la taille est un entier.

crop_size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*) : Taille de l'image de sortie après application de `center_crop`.

resample (`Annotated[Union[int, PILImageResampling, NoneType], None]`, *kwargs*) : Filtre de rééchantillonnage à utiliser lors du redimensionnement de l'image. Il peut s'agir d'une des valeurs de l'énumération `PILImageResampling`. N'a un effet que si `do_resize` est défini sur `True`.

do_rescale (`bool`, *kwargs*, *facultatif*) : Indique s'il faut rééchelonner l'image.

rescale_factor (`float`, *kwargs*, *facultatif*) : Facteur de redimensionnement à appliquer à l'image si `do_rescale` est défini sur `True`.

do_normalize (`bool`, *kwargs*, *facultatif*) : Indique s'il faut normaliser l'image.

image_mean (`Union[float, list[float], tuple[float, ...]]`, *kwargs*, *facultatif*) : Moyenne de l'image à utiliser pour la normalisation. N'a un effet que si `do_normalize` est défini sur `True`.

image_std (`Union[float, list[float], tuple[float, ...]]`, *kwargs*, *facultatif*) : Écart-type de l'image à utiliser pour la normalisation. N'a un effet que si `do_normalize` est défini sur `True`.

do_pad (`bool`, *kwargs*, *facultatif*) : Indique s'il faut ajouter un rembourrage à l'image. Le rembourrage est effectué soit jusqu'à la plus grande taille du lot, soit jusqu'à une taille carrée fixe par image. La stratégie de rembourrage exacte dépend du modèle.

pad_size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*) : La taille au format `{"height": int, "width" int}` à laquelle rembourrer les images. Elle doit être supérieure à la taille de n'importe quelle image fournie pour le prétraitement. Si `pad_size` n'est pas fourni, les images seront rembourrées à la hauteur et à la largeur maximales du lot. Appliqué uniquement lorsque `do_pad=True.`

do_center_crop (`bool`, *kwargs*, *facultatif*) : Indique s'il faut effectuer un recadrage centré de l'image.

data_format (`Union[str, ~image_utils.ChannelDimension]`, *kwargs*, *facultatif*) : Seul `ChannelDimension.FIRST` est pris en charge. Ajouté pour assurer la compatibilité avec les processeurs lents.

input_data_format (`Union[str, ~image_utils.ChannelDimension]`, *kwargs*, *facultatif*) : Le format de la dimension des canaux pour l'image d'entrée. Si non défini, le format de la dimension des canaux est déduit de l'image d'entrée. Peut être l'un des éléments suivants : - `"channels_first"` ou `ChannelDimension.FIRST` : image au format (num_channels, height, width). - `"channels_last"` ou `ChannelDimension.LAST` : image au format (height, width, num_channels). - `"none"` ou `ChannelDimension.NONE` : image au format (height, width).

device (`Annotated[Union[str, torch.device, NoneType], None]`, *kwargs*) : L'appareil sur lequel traiter les vidéos. Si non défini, l'appareil est déduit des vidéos d'entrée.

return_tensors (`Annotated[str | ~utils.generic.TensorType | None, None]`, *kwargs*) : Renvoie des tenseurs empilés si la valeur est `'pt'`, sinon renvoie une liste de tenseurs.

disable_grouping (`bool`, *kwargs*, *facultatif*) : Indique s'il faut désactiver le regroupement des images par taille afin de les traiter individuellement plutôt que par lots. Si la valeur est None, elle sera définie sur True si les images sont sur CPU, et sur False dans le cas contraire. Ce choix repose sur des observations empiriques, comme détaillé ici : https://github.com/huggingface/transformers/pull/38157

image_seq_length (`int`, *kwargs*, *facultatif*) : Le nombre de jetons d'image à utiliser pour chaque image de l'entrée. Ajouté pour la compatibilité ascendante, mais cela devrait être défini comme un attribut du processeur dans les futurs modèles.

patch_size (`int`, *kwargs*, *facultatif*, valeur par défaut 16) : Côté, en pixels, d'un patch de la tour visuelle.

downsample_ratio (`float`, *kwargs*, *facultatif*, valeur par défaut 0,5) : Ratio de sous-échantillonnage spatial par pixel-shuffle appliqué par le modèle ; chaque côté de la grille de patches est un multiple de sa réciproque.

min_num_patches (`int`, *kwargs*, *facultatif*, valeur par défaut 1024) : Nombre minimal de patches de `patch_size` vers lesquels une image est redimensionnée.

max_num_patches (`int`, *kwargs*, *facultatif*, valeur par défaut 13312) : Nombre maximal de patches de taille `patch_size` vers lesquels une image est redimensionnée ; `0` désactive cette limite.

max_model_len (`int`, *kwargs*, *facultatif*, valeur par défaut 16384) : Longueur de contexte du modèle de langage, qui limite le budget de patches des images dans un seul appel.

**Retourne :** `~image_processing_base.BatchFeature`

- **data** (`dict`) -- Dictionnaire de listes/tableaux/tenseurs renvoyé par la méthode __call__ (« pixel_values », etc.).
- **tensor_type** (`Union[None, str, TensorType]`, *facultatif*) -- Vous pouvez spécifier un tensor_type ici pour convertir les listes d'entiers en tenseurs PyTorch/Numpy lors de l'initialisation.

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

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

**Paramètres :**

- ****kwargs** (`NemotronH_Omni_Reasoning_V3VideoProcessorInitKwargs`, *facultatif*) : Options de traitement supplémentaires pour chaque modalité (texte, images, vidéos, audio). Les paramètres spécifiques au modèle sont répertoriés ci-dessus ; consultez la classe TypedDict pour la liste complète des arguments pris en charge.

Construit un processeur vidéo 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)
```

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

**Paramètres :**

image_processor (`NemotronH_Omni_Reasoning_V3ImageProcessor`) : le processeur d'images est une entrée obligatoire.

video_processor (`NemotronH_Omni_Reasoning_V3VideoProcessor`) : le processeur vidéo est une entrée obligatoire.

tokenizer (`tokenizer_class`) : Le tokenizer est une entrée obligatoire.

feature_extractor (`feature_extractor_class`) : l'extracteur de caractéristiques est une entrée obligatoire.

chat_template (`str`) : Un modèle Jinja pour convertir des listes de messages d'une conversation en une chaîne tokenisable.

audio_sampling_rate (`int`, *facultatif*, valeur par défaut 16000) : Fréquence d'échantillonnage, en Hz, à laquelle les formes d'onde audio sont censées être.

audio_subsampling_factor (`int`, *facultatif*, valeur par défaut : 8) : Facteur par lequel l'encodeur audio sous-échantillonne les trames mel, utilisé pour dimensionner la séquence de jetons de remplissage audio.

audio_hop_length (`int`, *facultatif*, valeur par défaut 160) : Longueur de saut, en échantillons, entre les trames mel consécutives.

video_temporal_patch_dim (`int`, *facultatif*, valeur par défaut : 2) : Nombre d'images regroupées en un seul patch temporel par l'encodeur vidéo du modèle.

Construit un NemotronH_Omni_Reasoning_V3Processor qui encapsule un processeur d’images, un processeur de vidéos, un tokeniseur et un extracteur de caractéristiques en un seul processeur.

[NemotronH_Omni_Reasoning_V3Processor](/docs/transformers/v5.23.0/fr/model_doc/nemotron_h_omni#transformers.NemotronH_Omni_Reasoning_V3Processor) offre toutes les fonctionnalités de [NemotronH_Omni_Reasoning_V3ImageProcessor](/docs/transformers/v5.23.0/fr/model_doc/nemotron_h_omni#transformers.NemotronH_Omni_Reasoning_V3ImageProcessor), [NemotronH_Omni_Reasoning_V3VideoProcessor](/docs/transformers/v5.23.0/fr/model_doc/nemotron_h_omni#transformers.NemotronH_Omni_Reasoning_V3VideoProcessor), `tokenizer_class` et `feature_extractor_class`. Consultez [~NemotronH_Omni_Reasoning_V3ImageProcessor](/docs/transformers/v5.23.0/fr/model_doc/nemotron_h_omni#transformers.NemotronH_Omni_Reasoning_V3ImageProcessor), [~NemotronH_Omni_Reasoning_V3VideoProcessor](/docs/transformers/v5.23.0/fr/model_doc/nemotron_h_omni#transformers.NemotronH_Omni_Reasoning_V3VideoProcessor), `~tokenizer_class` et `~feature_extractor_class` pour plus d’informations.

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

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

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

Transmettre à [batch_decode()](/docs/transformers/v5.23.0/fr/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.batch_decode) du tokenizer.

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

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

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

Transmettre à la méthode [decode()](/docs/transformers/v5.23.0/fr/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.decode) du 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)
```

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

Décoder les identifiants de jetons générés par le modèle en texte.

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

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

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

Développer `<video>` en un fragment `<img>...</img>` par patch temporel (tubelet).

Chaque fragment est étiqueté avec les horodatages des images qu’il contient, séparés par « and » (« Frame » pour la première image du tubelet, « frame » pour les autres). Le tokenizer ne dispose pas d’un véritable jeton `<video>`, les fragments utilisent donc le jeton d’image ; le modèle distingue l’image de la vidéo selon l’argument `pixel_values_*` transmis.

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

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

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

**Paramètres :**

input_ids (`torch.LongTensor` de forme `(batch_size, sequence_length)`, *facultatif*) : Indices des jetons de la séquence d'entrée dans le vocabulaire. Le bourrage (padding) sera ignoré par défaut. Les indices peuvent être obtenus à l'aide de [AutoTokenizer](/docs/transformers/v5.23.0/fr/model_doc/auto#transformers.AutoTokenizer). Consultez [PreTrainedTokenizer.encode()](/docs/transformers/v5.23.0/fr/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) et [PreTrainedTokenizer.__call__()](/docs/transformers/v5.23.0/fr/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) pour plus de détails. [Que sont les identifiants d'entrée ?](../glossary#input-ids)

pixel_values (`torch.Tensor` de forme `(total_patches, num_channels * patch_size**2)`, *facultatif*) : Taches aplaties de toutes les images, concaténées, telles que renvoyées par le processeur d'images.

image_grid_hw (`torch.LongTensor` de forme `(num_images, 2)`, *facultatif*) : Grille de patches `(height, width)` de chaque image dans `pixel_values`.

pixel_values_videos (`torch.Tensor` de forme `(batch_size, num_frames, num_channels, frame_size, frame_size)`, *facultatif*) : Les tenseurs correspondant à la vidéo d’entrée. Les valeurs de pixels des vidéos peuvent être obtenues à l’aide de [NemotronH_Omni_Reasoning_V3VideoProcessor](/docs/transformers/v5.23.0/fr/model_doc/nemotron_h_omni#transformers.NemotronH_Omni_Reasoning_V3VideoProcessor). Voir [NemotronH_Omni_Reasoning_V3VideoProcessor.__call__()](/docs/transformers/v5.23.0/fr/model_doc/molmo2#transformers.Molmo2VideoProcessor.__call__) pour plus de détails ([NemotronH_Omni_Reasoning_V3Processor](/docs/transformers/v5.23.0/fr/model_doc/nemotron_h_omni#transformers.NemotronH_Omni_Reasoning_V3Processor) utilise [NemotronH_Omni_Reasoning_V3VideoProcessor](/docs/transformers/v5.23.0/fr/model_doc/nemotron_h_omni#transformers.NemotronH_Omni_Reasoning_V3VideoProcessor) pour le traitement des vidéos).

input_features (`torch.Tensor` de forme `(batch_size, num_frames, num_mel_bins)`, *facultatif*) : Caractéristiques Mel produites par le processeur, encodées et réparties sur les jetons de remplacement audio.

input_features_mask (`torch.Tensor` de forme `(batch_size, num_frames)`, *facultatif*) : Masque indiquant les tranches mel réelles de chaque clip rembourré.

attention_mask (`torch.Tensor` de forme `(batch_size, sequence_length)`, *facultatif*) : Masque pour éviter d'appliquer l'attention aux indices des jetons de bourrage. Les valeurs du masque sont choisies dans `[0, 1]` : - 1 pour les jetons qui ne sont **pas masqués**, - 0 pour les jetons qui sont **masqués**. [Qu'est-ce qu'un masque d'attention ?](../glossary#attention-mask)

position_ids (`torch.LongTensor` de forme `(batch_size, sequence_length)`, *facultatif*) : Indices des positions des jetons de chaque séquence d'entrée dans les embeddings de position. Sélectionnés dans l'intervalle `[0, config.n_positions - 1]`.  [Que sont les identifiants de position ?](../glossary#position-ids)

past_key_values (`~cache_utils.Cache`, *facultatif*) : États cachés précalculés (clés et valeurs dans les blocs d'auto-attention et dans les blocs d'attention croisée) qui peuvent être utilisés pour accélérer le décodage séquentiel. Il s'agit généralement des `past_key_values` renvoyés par le modèle à une étape antérieure du décodage, lorsque `use_cache=True` ou `config.use_cache=True`.  Seule une instance de [Cache](/docs/transformers/v5.23.0/fr/internal/generation_utils#transformers.Cache) est autorisée en entrée, voir notre [guide sur le cache kv](https://huggingface.co/docs/transformers/en/kv_cache). Si aucun `past_key_values` n'est transmis, [DynamicCache](/docs/transformers/v5.23.0/fr/internal/generation_utils#transformers.DynamicCache) est initialisé par défaut.  Le modèle renverra le même format de cache que celui fourni en entrée.  Si `past_key_values` sont utilisés, l'utilisateur doit fournir uniquement les `input_ids` non traités (ceux pour lesquels les états de clés et de valeurs passées ne sont pas fournis à ce modèle) de forme `(batch_size, unprocessed_length)` au lieu de tous les `input_ids` de forme `(batch_size, sequence_length)`.

labels (`torch.LongTensor` de forme `(batch_size, sequence_length)`, *facultatif*) : Étiquettes pour le calcul de la perte de modélisation de langage masquée. Les indices doivent être compris dans `[0, ..., config.vocab_size]` ou égaux à -100 (voir la docstring de `input_ids`). Les jetons dont l'indice est défini sur `-100` sont ignorés (masqués) ; la perte n'est calculée que pour les jetons dont l'étiquette est comprise dans `[0, ..., config.vocab_size]`.

inputs_embeds (`torch.Tensor` de forme `(batch_size, sequence_length, hidden_size)`, *facultatif*) : Facultativement, au lieu de passer `input_ids`, vous pouvez choisir de passer directement une représentation intégrée. Cela est utile si vous souhaitez un meilleur contrôle sur la manière de convertir les indices `input_ids` en vecteurs associés, par rapport à la matrice de recherche d'intégration interne du modèle.

use_cache (`bool`, *facultatif*) : Si défini sur `True`, les états clé-valeur de `past_key_values` sont renvoyés et peuvent être utilisés pour accélérer le décodage (voir `past_key_values`).

mm_encoder_outputs (`dict[str, ~modeling_outputs.BaseModelOutputWithPooling]`, *facultatif*) : Dictionnaire dont les clés sont les modalités prises en charge et les valeurs sont les sorties encodées pour cette modalité. Chaque sortie encodée est un tuple composé de (`pooler_output`, *facultatif* : `last_hidden_states`, *facultatif* : `hidden_states`, *facultatif* : `attentions`) `pooler_output` de forme `(batch_size, sequence_length, hidden_size)`, *facultatif*) est une séquence de fonctionnalités multimodales de l'encodeur fusionnées dans les embeddings de texte.

**Retourne :** [CausalLMOutputWithPast](/docs/transformers/v5.23.0/fr/main_classes/output#transformers.modeling_outputs.CausalLMOutputWithPast) ou `tuple(torch.Tensor)`

Un [CausalLMOutputWithPast](/docs/transformers/v5.23.0/fr/main_classes/output#transformers.modeling_outputs.CausalLMOutputWithPast) ou un tuple de `torch.Tensor` (si `return_dict=False` est passé ou lorsque `config.return_dict=False`) comprenant divers éléments selon la configuration ([NemotronH_Omni_Reasoning_V3_Config](/docs/transformers/v5.23.0/fr/model_doc/nemotron_h_omni#transformers.NemotronH_Omni_Reasoning_V3_Config)) et les entrées.

La méthode forward de [NemotronH_Omni_Reasoning_V3](/docs/transformers/v5.23.0/fr/model_doc/nemotron_h_omni#transformers.NemotronH_Omni_Reasoning_V3) redéfinit la méthode spéciale `__call__`.

Bien que la recette de la passe avant doive être définie dans cette fonction, il faut ensuite appeler l'instance `Module` plutôt que celle-ci, car la première gère l'exécution des étapes de prétraitement et de post-traitement, tandis que la seconde les ignore silencieusement.

- **loss** (`torch.Tensor` de forme `(1,)`, *facultatif*, renvoyé lorsque `labels` est fourni) -- Perte de modélisation du langage (pour la prédiction du jeton suivant).
- **logits** (`torch.Tensor` de forme `(batch_size, sequence_length, config.vocab_size)`) -- Scores de prédiction de la tête de modélisation du langage (scores pour chaque jeton du vocabulaire avant SoftMax).
- **past_key_values** (`Cache`, *facultatif*, renvoyé lorsque `use_cache=True` est passé ou lorsque `config.use_cache=True`) -- Il s'agit d'une instance de [Cache](/docs/transformers/v5.23.0/fr/internal/generation_utils#transformers.Cache). Pour plus de détails, consultez notre [guide sur le cache kv](https://huggingface.co/docs/transformers/en/kv_cache).

  Contient des états cachés précalculés (clés et valeurs dans les blocs d'auto-attention) qui peuvent être utilisés (voir l'entrée `past_key_values`) pour accélérer le décodage séquentiel.
- **hidden_states** (`tuple(torch.Tensor)`, *facultatif*, renvoyé lorsque `output_hidden_states=True` est passé ou lorsque `config.output_hidden_states=True`) -- Tuple de `torch.Tensor` (un pour la sortie des embeddings, si le modèle possède une couche d’embedding, + un pour la sortie de chaque couche) de forme `(batch_size, sequence_length, hidden_size)`.

  États cachés du modèle à la sortie de chaque couche, ainsi que les sorties d'incorporation initiales facultatives.
- **attentions** (`tuple(torch.Tensor)`, *facultatif*, renvoyé lorsque `output_attentions=True` est passé ou lorsque `config.output_attentions=True`) -- Tuple de `torch.Tensor` (un par couche) de forme `(batch_size, num_heads, sequence_length, sequence_length)`.

  Pondérations des attentions après le softmax d'attention, utilisées pour calculer la moyenne pondérée dans les têtes d'auto-attention.

Exemple :

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

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

**Paramètres :**

inputs (`torch.Tensor` de forme variable selon la modalité, *facultatif*) : La séquence utilisée comme invite pour la génération ou comme entrées du modèle pour l'encodeur. Si `None`, la méthode l'initialise avec `bos_token_id` et une taille de lot de 1. Pour les modèles uniquement décodeurs, `inputs` doit être au format de `input_ids`. Pour les modèles encodeur-décodeur, *inputs* peut représenter l'un des éléments suivants : `input_ids`, `input_values`, `input_features` ou `pixel_values`.

generation_config ([GenerationConfig](/docs/transformers/v5.23.0/fr/main_classes/text_generation#transformers.GenerationConfig), *facultatif*) : La configuration de génération à utiliser comme paramétrage de base pour l'appel de génération. Les `**kwargs` passés à generate qui correspondent aux attributs de `generation_config` les remplaceront. Si `generation_config` n'est pas fourni, la valeur par défaut sera utilisée, avec la priorité de chargement suivante : 1) depuis le fichier modèle `generation_config.json`, s'il existe ; 2) depuis la configuration du modèle. Veuillez noter que les paramètres non spécifiés hériteront des valeurs par défaut de [GenerationConfig](/docs/transformers/v5.23.0/fr/main_classes/text_generation#transformers.GenerationConfig), dont la documentation doit être consultée pour paramétrer la génération.

logits_processor (`LogitsProcessorList`, *facultatif*) : Processeurs de logits personnalisés qui complètent les processeurs de logits par défaut créés à partir des arguments et de la configuration de génération. Si un processeur de logits est transmis qui a déjà été créé avec les arguments ou une configuration de génération, une erreur est levée. Cette fonctionnalité est destinée aux utilisateurs avancés.

stopping_criteria (`StoppingCriteriaList`, *facultatif*) : Critères d'arrêt personnalisés qui complètent les critères d'arrêt par défaut construits à partir des arguments et d'une configuration de génération. Si un critère d'arrêt est transmis qui a déjà été créé à partir des arguments ou d'une configuration de génération, une erreur est levée. Si votre critère d'arrêt dépend de l'entrée `scores`, assurez-vous de passer `return_dict_in_generate=True, output_scores=True` à `generate`. Cette fonctionnalité est destinée aux utilisateurs avancés.

prefix_allowed_tokens_fn (`Callable[[int, torch.Tensor], list[int]]`, *facultatif*) : Si fournie, cette fonction contraint la recherche par faisceau aux jetons autorisés uniquement à chaque étape. Si elle n'est pas fournie, aucune contrainte n'est appliquée. Cette fonction prend 2 arguments : l'identifiant du lot `batch_id` et `input_ids`. Elle doit retourner une liste des jetons autorisés pour l'étape de génération suivante, conditionnée par l'identifiant du lot `batch_id` et les jetons précédemment générés `inputs_ids`. Cet argument est utile pour la génération contrainte conditionnée par le préfixe, comme décrit dans [Autoregressive Entity Retrieval](https://huggingface.co/papers/2010.00904).

synced_gpus (`bool`, *facultatif*) : Indique s'il faut continuer à exécuter la boucle while jusqu'à max_length. Sauf si cette valeur est remplacée, ce drapeau est défini sur `True` lors de l'utilisation de `FullyShardedDataParallel` ou de DeepSpeed ZeRO Stage 3 avec plusieurs GPU, afin d'éviter tout blocage si un GPU termine la génération avant les autres. Sinon, la valeur par défaut est `False`.

assistant_model (`PreTrainedModel`, *facultatif*) : Un modèle assistant pouvant être utilisé pour accélérer la génération. Le modèle assistant doit utiliser exactement le même tokenizer. L'accélération est obtenue lorsque la prédiction des jetons candidats par le modèle assistant est beaucoup plus rapide que l'exécution de la génération avec le modèle depuis lequel vous appelez generate. Par conséquent, le modèle assistant doit être beaucoup plus petit.

streamer (`BaseStreamer`, *facultatif*) : Objet Streamer qui sera utilisé pour diffuser les séquences générées. Les jetons générés sont transmis via `streamer.put(token_ids)` et le streamer est responsable de tout traitement ultérieur.

negative_prompt_ids (`torch.LongTensor` de forme `(batch_size, sequence_length)`, *facultatif*) : Le prompt négatif requis par certains processeurs tels que CFG. La taille du lot doit correspondre à la taille du lot d'entrée. Il s'agit d'une fonctionnalité expérimentale, susceptible de subir des modifications cassant l'API dans les versions futures.

negative_prompt_attention_mask (`torch.LongTensor` de forme `(batch_size, sequence_length)`, *facultatif*) : Attention_mask pour `negative_prompt_ids`.

custom_generate (`str` ou `Callable`, *facultatif*) : L'un des éléments suivants : - `str` (nom du dépôt sur le Hugging Face Hub) : exécute la fonction `generate` personnalisée définie dans `custom_generate/generate.py` de ce dépôt, à la place de la méthode standard `generate`. Le dépôt remplace entièrement la logique de génération, et le type de retour peut différer. - `str` (chemin d'accès local au dépôt) : idem, mais à partir d'un chemin local. Les répertoires locaux nécessitent également `trust_remote_code=True`, car le fichier local `custom_generate/generate.py` est exécuté. - `Callable` : `generate` effectue les étapes habituelles de préparation des entrées, puis appelle le callable fourni pour exécuter la boucle de décodage. Pour plus d'informations, consultez [la documentation](../../generation_strategies#custom-generation-methods).

kwargs (`dict[str, Any]`, *facultatif*) : Paramétrage ad hoc de `generation_config` et/ou d'autres kwargs spécifiques au modèle qui seront transmis à la fonction `forward` du modèle. Si le modèle est un modèle encoder-décodeur, les kwargs spécifiques à l'encodeur ne doivent pas être préfixés et les kwargs spécifiques au décodeur doivent être préfixés par *decoder_*.

**Retourne :** [ModelOutput](/docs/transformers/v5.23.0/fr/main_classes/output#transformers.utils.ModelOutput) ou `torch.LongTensor`

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

Si le modèle n'*est pas* un modèle encodeur-décodeur (`model.config.is_encoder_decoder=False`), les types [ModelOutput](/docs/transformers/v5.23.0/fr/main_classes/output#transformers.utils.ModelOutput) possibles sont :

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

Si le modèle est un modèle encodeur-décodeur (`model.config.is_encoder_decoder=True`), les types [ModelOutput](/docs/transformers/v5.23.0/fr/main_classes/output#transformers.utils.ModelOutput) possibles sont :

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

Génère des séquences d'identifiants de jetons pour les modèles dotés d'une tête de modélisation de langage.

La plupart des paramètres de contrôle de la génération sont définis dans `generation_config` qui, s'il n'est pas transmis, sera réglé sur la configuration de génération par défaut du modèle. Vous pouvez remplacer n'importe quel `generation_config` en transmettant les paramètres correspondants à generate(), par exemple `.generate(inputs, num_beams=4, do_sample=True)`.

Pour un aperçu des stratégies de génération et des exemples de code, consultez le [guide suivant](../generation_strategies).