# Qwen2.5-Omni

## Aperçu

Le modèle [Qwen2.5-Omni](https://qwenlm.github.io/blog/qwen2.5-omni/) est un modèle unifié multi-modalités proposé dans le [Qwen2.5-Omni Technical Report](https://huggingface.co/papers/2503.20215) par l'équipe Qwen du groupe Alibaba.

L'abstract du rapport technique est le suivant :

*Nous présentons Qwen2.5-Omni, un modèle multimodal de bout en bout conçu pour percevoir diverses modalités, notamment le texte, les images, l'audio et la vidéo, tout en générant simultanément des réponses textuelles et vocales naturelles de manière en flux continu. Pour permettre le flux des entrées d'informations multimodales, les encodeurs audio et visuels utilisent tous deux une approche de traitement par blocs. Cette stratégie découple efficacement le traitement des longues séquences de données multimodales, en confiant les responsabilités perceptives à l'encodeur multimodal et la modélisation des séquences étendues à un grand modèle de langage. Cette division du travail renforce la fusion des différentes modalités via le mécanisme d'attention partagé. Pour synchroniser les horodatages des entrées vidéo avec l'audio, nous avons organisé l'audio et la vidéo de manière séquentielle et entrelacée, et proposons une nouvelle approche d'incorporation de position, nommée TMRoPE (Time-aligned Multimodal RoPE). Pour générer simultanément du texte et de la parole tout en évitant les interférences entre les deux modalités, nous proposons l'architecture Thinker-Talker. Dans ce cadre, Thinker fonctionne comme un grand modèle de langage chargé de la génération de texte, tandis que Talker est un modèle autorégressif à double piste qui utilise directement les représentations cachées de Thinker pour produire des jetons audio en sortie. Les modèles Thinker et Talker sont tous deux conçus pour être entraînés et inférés de manière de bout en bout. Pour décoder les jetons audio de manière en flux continu, nous introduisons un DiT à fenêtre glissante qui restreint le champ récepteur, afin de réduire le délai initial du paquet. Qwen2.5-Omni surpasse Qwen2-VL et Qwen2-Audio de taille similaire en termes de capacités en image et en audio. De plus, Qwen2.5-Omni atteint des performances de pointe sur des benchmarks multimodaux tels qu'Omni-Bench. Notamment, Qwen2.5-Omni est le premier modèle open source à atteindre un niveau de performance dans le suivi d'instructions vocales de bout en bout comparable à ses capacités avec des entrées textuelles, comme en témoignent des benchmarks tels que MMLU et GSM8K. En ce qui concerne la génération de parole, le Talker en flux continu de Qwen2.5-Omni surpasse la plupart des alternatives existantes en flux et hors flux en termes de robustesse et de naturalité.*

> [!TIP]
> Définissez `use_kernels=True` dans [from_pretrained()](/docs/transformers/v5.23.0/fr/main_classes/model#transformers.PreTrainedModel.from_pretrained) pour remplacer les couches prises en charge par des noyaux optimisés du Hub. Consultez [Chargement des noyaux](../kernel_doc/loading_kernels) pour en savoir plus.

## Notes

- Utilisez [Qwen2_5OmniForConditionalGeneration](/docs/transformers/v5.23.0/fr/model_doc/qwen2_5_omni#transformers.Qwen2_5OmniForConditionalGeneration) pour générer une sortie audio et texte. Pour générer un seul type de sortie, utilisez [Qwen2_5OmniThinkerForConditionalGeneration](/docs/transformers/v5.23.0/fr/model_doc/qwen2_5_omni#transformers.Qwen2_5OmniThinkerForConditionalGeneration) pour le texte uniquement et `Qwen2_5OmniTalkersForConditionalGeneration` pour l’audio uniquement.
- En cas d'erreurs de mémoire insuffisante lors du traitement d'entrées vidéo, diminuez `processor.max_pixels`. Par défaut, la valeur maximale est fixée à un nombre très élevé et les visuels haute résolution ne sont pas redimensionnés, sauf si la résolution dépasse `processor.max_pixels`.
- Le processeur dispose de sa propre méthode [apply_chat_template()](/docs/transformers/v5.23.0/fr/main_classes/processors#transformers.ProcessorMixin.apply_chat_template) pour convertir les messages de chat en entrées du modèle.

## Exemple d'utilisation

`Qwen2.5-Omni` est disponible sur le [Huggingface Hub](https://huggingface.co/Qwen).

### Inférence sur un seul média

Le modèle peut accepter du texte, des images, de l'audio et des vidéos en entrée. Voici un exemple de code pour l'inférence.

```python
import soundfile as sf

from transformers import Qwen2_5OmniForConditionalGeneration, Qwen2_5OmniProcessor

model = Qwen2_5OmniForConditionalGeneration.from_pretrained(
    "Qwen/Qwen2.5-Omni-7B",
    device_map="auto",
)
processor = Qwen2_5OmniProcessor.from_pretrained("Qwen/Qwen2.5-Omni-7B")

conversations = [
    {
        "role": "system",
        "content": [
            {"type": "text", "text": "You are Qwen, a virtual human developed by the Qwen Team, Alibaba Group, capable of perceiving auditory and visual inputs, as well as generating text and speech."}
        ],
    },
    {
        "role": "user",
        "content": [
            {"type": "video", "video": "/path/to/video.mp4"},
            {"type": "text", "text": "What can't you hear and see in this video?"},
        ],
    },
]

inputs = processor.apply_chat_template(
    conversations,
    load_audio_from_video=True,
    add_generation_prompt=True,
    tokenize=True,
    return_dict=True,
    return_tensors="pt",
    fps=1,

    # kwargs to be passed to `Qwen2-5-OmniProcessor`
    padding=True,
    use_audio_in_video=True,
).to(model.device)

# Generation params for audio or text can be different and have to be prefixed with `thinker_` or `talker_`
text_ids, audio = model.generate(**inputs, use_audio_in_video=True, thinker_do_sample=False, talker_do_sample=True)
text = processor.batch_decode(text_ids, skip_special_tokens=True, clean_up_tokenization_spaces=False)

sf.write(
    "output.wav",
    audio.reshape(-1).detach().cpu().numpy(),
    samplerate=24000,
)
print(text)
```

### Génération de texte uniquement

Pour générer uniquement une sortie texte et économiser des ressources de calcul en ne chargeant pas le modèle de génération audio, nous pouvons utiliser le modèle `Qwen2_5OmniThinkerForConditionalGeneration`.

```python
from transformers import Qwen2_5OmniProcessor, Qwen2_5OmniThinkerForConditionalGeneration

model = Qwen2_5OmniThinkerForConditionalGeneration.from_pretrained(
    "Qwen/Qwen2.5-Omni-7B",
    device_map="auto",
)
processor = Qwen2_5OmniProcessor.from_pretrained("Qwen/Qwen2.5-Omni-7B")

conversations = [
    {
        "role": "system",
        "content": [
            {"type": "text", "text": "You are Qwen, a virtual human developed by the Qwen Team, Alibaba Group, capable of perceiving auditory and visual inputs, as well as generating text and speech."}
        ],
    },
    {
        "role": "user",
        "content": [
            {"type": "video", "video": "/path/to/video.mp4"},
            {"type": "text", "text": "What can't you hear and see in this video?"},
        ],
    },
]

inputs = processor.apply_chat_template(
    conversations,
    load_audio_from_video=True,
    add_generation_prompt=True,
    tokenize=True,
    return_dict=True,
    return_tensors="pt",
    fps=1,

    # kwargs to be passed to `Qwen2-5-OmniProcessor`
    padding=True,
    use_audio_in_video=True,
).to(model.device)

text_ids = model.generate(**inputs, use_audio_in_video=True)
text = processor.batch_decode(text_ids, skip_special_tokens=True, clean_up_tokenization_spaces=False)

print(text)
```

### Inférence par lots sur des médias mixtes

Le modèle peut traiter par lots des entrées composées d'échantillons mixtes de divers types, tels que du texte, des images, de l'audio et des vidéos, lorsqu'il utilise le modèle `Qwen2_5OmniThinkerForConditionalGeneration`. Voici un exemple.

```python
from transformers import Qwen2_5OmniForConditionalGeneration, Qwen2_5OmniProcessor

model = Qwen2_5OmniForConditionalGeneration.from_pretrained(
    "Qwen/Qwen2.5-Omni-7B",
    device_map="auto"
)
processor = Qwen2_5OmniProcessor.from_pretrained("Qwen/Qwen2.5-Omni-7B")

# Conversation with video only
conversation1 = [
    {
        "role": "system",
        "content": [
            {"type": "text", "text": "You are Qwen, a virtual human developed by the Qwen Team, Alibaba Group, capable of perceiving auditory and visual inputs, as well as generating text and speech."}
        ],
    },
    {
        "role": "user",
        "content": [
            {"type": "video", "path": "/path/to/video.mp4"},
        ]
    }
]

# Conversation with audio only
conversation2 = [
    {
        "role": "system",
        "content": [
            {"type": "text", "text": "You are Qwen, a virtual human developed by the Qwen Team, Alibaba Group, capable of perceiving auditory and visual inputs, as well as generating text and speech."}
        ],
    },
    {
        "role": "user",
        "content": [
            {"type": "audio", "path": "/path/to/audio.wav"},
        ]
    }
]

# Conversation with pure text
conversation3 = [
    {
        "role": "system",
        "content": [
            {"type": "text", "text": "You are Qwen, a virtual human developed by the Qwen Team, Alibaba Group, capable of perceiving auditory and visual inputs, as well as generating text and speech."}
        ],
    },
    {
        "role": "user",
        "content": [{"type": "text", "text": "who are you?"}],
    }
]

# Conversation with mixed media
conversation4 = [
    {
        "role": "system",
        "content": [
            {"type": "text", "text": "You are Qwen, a virtual human developed by the Qwen Team, Alibaba Group, capable of perceiving auditory and visual inputs, as well as generating text and speech."}
        ],
    },
    {
        "role": "user",
        "content": [
            {"type": "image", "path": "/path/to/image.jpg"},
            {"type": "video", "path": "/path/to/video.mp4"},
            {"type": "audio", "path": "/path/to/audio.wav"},
            {"type": "text", "text": "What are the elements can you see and hear in these media?"},
        ],
    }
]

conversations = [conversation1, conversation2, conversation3, conversation4]

inputs = processor.apply_chat_template(
    conversations,
    load_audio_from_video=True,
    add_generation_prompt=True,
    tokenize=True,
    return_dict=True,
    return_tensors="pt",
    fps=1,

    # kwargs to be passed to `Qwen2-5-OmniProcessor`
    padding=True,
    use_audio_in_video=True,
).to(model.thinker.device)

text_ids = model.generate(**inputs, use_audio_in_video=True)
text = processor.batch_decode(text_ids, skip_special_tokens=True, clean_up_tokenization_spaces=False)

print(text)
```

### Génération audio par lots

[Qwen2_5OmniForConditionalGeneration](/docs/transformers/v5.23.0/fr/model_doc/qwen2_5_omni#transformers.Qwen2_5OmniForConditionalGeneration) prend en charge la génération de sortie audio par lots. Par exemple, ci-dessous pour la génération par lots de texte vers parole. Avec un lot de plus d'un échantillon, l'audio généré est renvoyé sous forme de liste contenant une forme d'onde par échantillon, chacune déjà rognée à sa propre longueur, de sorte que les échantillons plus courts ne sont pas complétés par un audio parasite. Un appel avec un seul échantillon renvoie toujours un seul tenseur.

```python
import soundfile as sf
from transformers import AutoModelForTextToWaveform, AutoProcessor
import torch

model_id = "Qwen/Qwen2.5-Omni-7B"
model = AutoModelForTextToWaveform.from_pretrained(model_id, device_map="auto")
processor = AutoProcessor.from_pretrained(model_id)
sampling_rate = 24000  # output sampling rate
max_new_tokens = 200  # maximum number of tokens to generate

system_text = (
    "You are Qwen, a virtual human developed by the Qwen Team, Alibaba Group, capable of "
    "perceiving auditory and visual inputs, as well as generating text and speech."
)
texts = [
    "Hello, I'm Qwen. How can I help you today?",
    "The weather is nice today. Let's go for a walk.",
]
inputs = processor.apply_chat_template(
    [
        [
            {"role": "system", "content": [{"type": "text", "text": system_text}]},
            {
                "role": "user",
                "content": [
                    {
                        "type": "text",
                        "text": (
                            "Please read the following text aloud exactly as written, with no "
                            f"additional commentary:\n\n{text}"
                        ),
                    }
                ],
            },
        ]
        for text in texts
    ],
    tokenize=True,
    add_generation_prompt=True,
    return_dict=True,
    return_tensors="pt",
    processor_kwargs={"padding": True},
).to(model.device, dtype=model.dtype)

gen_kwargs = {
    "talker_do_sample": True,
    "speaker": "Ethan",  # Ethan, Chelsie
    "talker_max_new_tokens": max_new_tokens,
}
_, pred_waveform = model.generate(**inputs, **gen_kwargs)

for sample_id, audio in enumerate(pred_waveform):
    sf.write(
        f"qwen2_5_omni_output_{sample_id}.wav",
        audio.detach().to(torch.float32).cpu().numpy(),
        sampling_rate,
    )
    print(f"Saved audio to qwen2_5_omni_output_{sample_id}.wav")
```

### Conseils d'utilisation

#### Compromis sur la résolution d'image

Le modèle prend en charge une large gamme de résolutions d'entrée. Par défaut, il utilise la résolution native pour l'entrée, mais des résolutions plus élevées peuvent améliorer les performances au prix d'un calcul plus important. Les utilisateurs peuvent définir le nombre minimal et maximal de pixels pour obtenir une configuration optimale adaptée à leurs besoins.

```python
min_pixels = 128*28*28
max_pixels = 768*28*28
processor = AutoProcessor.from_pretrained("Qwen/Qwen2.5-Omni-7B", min_pixels=min_pixels, max_pixels=max_pixels)
```

#### Prompt pour la sortie audio

Si les utilisateurs ont besoin d’une sortie audio, le prompt système doit être défini comme « You are Qwen, a virtual human developed by the Qwen Team, Alibaba Group, capable of perceiving auditory and visual inputs, as well as generating text and speech. », sinon la sortie audio peut ne pas fonctionner comme prévu.

```python
{
    "role": "system",
    "content": "You are Qwen, a virtual human developed by the Qwen Team, Alibaba Group, capable of perceiving auditory and visual inputs, as well as generating text and speech.",
}
```

#### Utiliser la sortie audio ou non

Le modèle prend en charge à la fois les sorties texte et audio. Si les utilisateurs n’ont pas besoin de sorties audio, ils peuvent définir `enable_audio_output` dans la fonction `from_pretrained`. Cette option permet d’économiser environ `~2GB` de mémoire GPU, mais l’option `return_audio` de la fonction `generate` ne pourra alors être définie que sur `False`.

```python
model = Qwen2_5OmniForConditionalGeneration.from_pretrained(
    "Qwen/Qwen2.5-Omni-7B",
    device_map="auto",
    enable_audio_output=False,
)
```

Afin d’obtenir une expérience flexible, nous recommandons aux utilisateurs de définir `enable_audio_output` sur `True` lors de l’initialisation du modèle via la fonction `from_pretrained`, puis de décider s’il faut retourner de l’audio lorsque la fonction `generate` est appelée. Lorsque `return_audio` est défini sur `False`, le modèle ne renvoie que des sorties texte afin d’obtenir les réponses texte plus rapidement.

```python
model = Qwen2_5OmniForConditionalGeneration.from_pretrained(
    "Qwen/Qwen2.5-Omni-7B",
    device_map="auto",
    enable_audio_output=True,
)
...
text_ids = model.generate(**inputs, return_audio=False)
```

#### Changer le type de voix de l'audio de sortie

Qwen2.5-Omni prend en charge la modification de la voix de l’audio de sortie. Les utilisateurs peuvent utiliser le paramètre `speaker` de la fonction `generate` pour spécifier le type de voix. Le point de contrôle `"Qwen/Qwen2.5-Omni-7B"` prend en charge deux types de voix : `Chelsie` et `Ethan`, où `Chelsie` est une voix féminine et `Ethan` une voix masculine. Par défaut, si `speaker` n’est pas spécifié, le type de voix par défaut est `Chelsie`.

```python
text_ids, audio = model.generate(**inputs, speaker="Chelsie")
```

```python
text_ids, audio = model.generate(**inputs, speaker="Ethan")
```

#### Flash-Attention 2 pour accélérer la génération

Premièrement, assurez-vous d'installer la dernière version de Flash Attention 2 :

```bash
pip install -U flash-attn --no-build-isolation
```

De plus, vous devez disposer d'un matériel compatible avec FlashAttention 2. En savoir plus dans la documentation officielle du [dépôt flash attention](https://github.com/Dao-AILab/flash-attention). FlashAttention-2 ne peut être utilisé que lorsqu'un modèle est chargé en `torch.float16` ou `torch.bfloat16`.

Pour charger et exécuter un modèle en utilisant FlashAttention-2, ajoutez `attn_implementation="flash_attention_2"` lors du chargement du modèle :

```python
from transformers import Qwen2_5OmniForConditionalGeneration

model = Qwen2_5OmniForConditionalGeneration.from_pretrained(
    "Qwen/Qwen2.5-Omni-7B",
    device_map="auto",
    attn_implementation="flash_attention_2",
)
```

## Qwen2_5OmniConfig[[transformers.Qwen2_5OmniConfig]]

#### transformers.Qwen2_5OmniConfig[[transformers.Qwen2_5OmniConfig]]

```python
transformers.Qwen2_5OmniConfig(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, thinker_config: dict | transformers.configuration_utils.PreTrainedConfig | None = None, talker_config: dict | transformers.configuration_utils.PreTrainedConfig | None = None, token2wav_config: dict | transformers.configuration_utils.PreTrainedConfig | None = None, enable_audio_output: bool = True)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/qwen2_5_omni/configuration_qwen2_5_omni.py#L533)

**Paramètres :**

thinker_config (`dict`, *facultatif*) : Configuration du sous-modèle thinker sous-jacent.

talker_config (`dict`, *facultatif*) : Configuration du sous-modèle talker sous-jacent.

token2wav_config (`dict`, *facultatif*) : Configuration du sous-modèle de codec sous-jacent.

enable_audio_output (`bool`, *facultatif*, valeur par défaut `True`) : Indique s'il faut activer la sortie audio et charger les modules talker et token2wav.

Il s'agit de la classe de configuration destinée à stocker la configuration d'un modèle Qwen2 5 OmniModel. Elle est utilisée pour instancier un modèle Qwen2 5 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 [Qwen/Qwen2.5-Omni-7B](https://huggingface.co/Qwen/Qwen2.5-Omni-7B)

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.

Exemple :

```python
>>> from transformers import (
...     Qwen2_5OmniThinkerConfig,
...     Qwen2_5OmniTalkerConfig,
...     Qwen2_5OmniToken2WavConfig,
...     Qwen2_5OmniForConditionalGeneration,
...     Qwen2_5OmniConfig,
... )

>>> # Initializing sub-modules configurations.
>>> thinker_config = Qwen2_5OmniThinkerConfig()
>>> talker_config = Qwen2_5OmniTalkerConfig()
>>> token2wav_config = Qwen2_5OmniToken2WavConfig()

>>> # Initializing a module style configuration
>>> configuration = Qwen2_5OmniConfig(
...     thinker_config, talker_config, token2wav_config
... )

>>> # Initializing a model (with random weights)
>>> model = Qwen2_5OmniForConditionalGeneration(configuration)

>>> # Accessing the model configuration
>>> configuration = model.config
```

#### get_text_config[[transformers.Qwen2_5OmniConfig.get_text_config]]

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

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/qwen2_5_omni/configuration_qwen2_5_omni.py#L586)

**Paramètres :**

decoder (`Optional[bool]`, *facultatif*, valeur par défaut `False`) : Si défini sur `True`, recherche uniquement les noms de configuration du décodeur.

Retourne la configuration destinée à être utilisée avec l'entrée/sortie de texte. Pour la plupart des modèles, il s'agit de l'instance de configuration d'origine elle-même. Pour certains modèles composites, elle se trouve sous l'un des noms valides.

## Qwen2_5OmniVisionEncoderConfig[[transformers.Qwen2_5OmniVisionEncoderConfig]]

#### transformers.Qwen2_5OmniVisionEncoderConfig[[transformers.Qwen2_5OmniVisionEncoderConfig]]

```python
transformers.Qwen2_5OmniVisionEncoderConfig(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, depth: int = 32, hidden_size: int = 3584, hidden_act: str = 'silu', intermediate_size: int = 3420, num_heads: int = 16, in_channels: int = 3, patch_size: int | list[int] | tuple[int, int] = 14, spatial_merge_size: int = 2, temporal_patch_size: int | list[int] | tuple[int, int] = 2, window_size: int = 112, out_hidden_size: int = 3584, fullatt_block_indexes: list[int] | tuple[int, ...] = (7, 15, 23, 31), initializer_range: float = 0.02, rope_parameters: dict | None = None)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/qwen2_5_omni/configuration_qwen2_5_omni.py#L30)

**Paramètres :**

depth (`int`, *facultatif*, valeur par défaut `32`) : Nombre de couches Transformer dans l'encodeur visuel.

hidden_size (`int`, *facultatif*, valeur par défaut `3584`) : Dimension des représentations cachées.

hidden_act (`str`, *facultatif*, par défaut `silu`) : La fonction d'activation non linéaire (fonction ou chaîne de caractères) dans le décodeur. Par exemple, `"gelu"`, `"relu"`, `"silu"`, etc.

intermediate_size (`int`, *facultatif*, valeur par défaut `3420`) : Dimension des représentations MLP.

num_heads (`int`, *facultatif*, valeur par défaut `16`) : Nombre de têtes d'attention pour chaque couche d'attention du décodeur Transformer.

in_channels (`int`, *facultatif*, par défaut `3`) : Le nombre de canaux d'entrée.

patch_size (`Union[int, list[int], tuple[int, int]]`, *facultatif*, valeur par défaut `14`) : La taille (résolution) de chaque patch.

spatial_merge_size (`int`, *facultatif*, valeur par défaut `2`) : La taille de la fenêtre de fusion spatiale utilisée pour réduire le nombre de jetons visuels en fusionnant les patches voisins.

temporal_patch_size (`Union[int, list[int], tuple[int, int]]`, *facultatif*, valeur par défaut `2`) : Taille de patch temporel utilisée dans l'intégration de patch 3D pour les entrées vidéo.

window_size (`int`, *facultatif*, valeur par défaut 11) : Taille des fenêtres.

out_hidden_size (`int`, *facultatif*, valeur par défaut 3584) : La taille de sortie cachée du modèle de vision.

fullatt_block_indexes (`int`, *facultatif*, par défaut `[7, 15, 23, 31]`) : Indices des couches avec attention complète

initializer_range (`float`, *facultatif*, valeur par défaut `0.02`) : L'écart-type de la truncated_normal_initializer utilisé pour l'initialisation de toutes les matrices de poids.

rope_parameters (`dict`, *facultatif*) : Dictionnaire contenant les paramètres de configuration pour les embeddings RoPE. Le dictionnaire doit contenir une valeur pour `rope_theta` et, le cas échéant, les paramètres utilisés pour le mise à l'échelle si vous souhaitez utiliser RoPE avec des `max_position_embeddings` plus longs.

Il s'agit de la classe de configuration destinée à stocker la configuration d'un modèle Qwen2 5 OmniModel. Elle est utilisée pour instancier un modèle Qwen2 5 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 [Qwen/Qwen2.5-Omni-7B](https://huggingface.co/Qwen/Qwen2.5-Omni-7B)

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.

Exemple :

```python
>>> from transformers import Qwen2_5OmniVisionEncoderConfig, Qwen2_5OmniVisionEncoder

>>> # Initializing a Qwen2_5OmniVisionEncoderConfig
>>> configuration = Qwen2_5OmniVisionEncoderConfig()

>>> # Initializing a Qwen2_5OmniVisionEncoder (with random weights)
>>> model = Qwen2_5OmniVisionEncoder(configuration)

>>> # Accessing the model configuration
>>> configuration = model.config
```

## Qwen2_5OmniTextConfig[[transformers.Qwen2_5OmniTextConfig]]

#### transformers.Qwen2_5OmniTextConfig[[transformers.Qwen2_5OmniTextConfig]]

```python
transformers.Qwen2_5OmniTextConfig(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, vocab_size: int = 152064, hidden_size: int = 3584, intermediate_size: int = 18944, num_hidden_layers: int = 28, num_attention_heads: int = 28, num_key_value_heads: int | None = 4, hidden_act: str = 'silu', max_position_embeddings: int = 32768, initializer_range: float = 0.02, rms_norm_eps: float = 1e-06, use_cache: bool = True, rope_parameters: transformers.modeling_rope_utils.RopeParameters | dict | None = None, use_sliding_window: bool = False, sliding_window: int | None = 32768, max_window_layers: int = 28, layer_types: list[str] | None = None, attention_dropout: float | int = 0.0, pad_token_id: int | None = None, bos_token_id: int | None = None, eos_token_id: int | list[int] | None = None, tie_word_embeddings: bool = True)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/qwen2_5_omni/configuration_qwen2_5_omni.py#L128)

**Paramètres :**

vocab_size (`int`, *facultatif*, valeur par défaut `152064`) : Taille du vocabulaire du modèle. Définit le nombre de jetons différents qui peuvent être représentés par `input_ids`.

hidden_size (`int`, *facultatif*, valeur par défaut `3584`) : Dimension des représentations cachées.

intermediate_size (`int`, *facultatif*, par défaut `18944`) : Dimension des représentations MLP.

num_hidden_layers (`int`, *facultatif*, par défaut `28`) : Nombre de couches cachées dans le décodeur Transformer.

num_attention_heads (`int`, *facultatif*, valeur par défaut `28`) : Nombre de têtes d'attention pour chaque couche d'attention du décodeur Transformer.

num_key_value_heads (`int`, *facultatif*, valeur par défaut `4`) : C'est le nombre de têtes key_value à utiliser pour implémenter l'attention Grouped Query. Si `num_key_value_heads=num_attention_heads`, le modèle utilisera l'attention Multi Head (MHA) ; si `num_key_value_heads=1`, il utilisera l'attention Multi Query (MQA) ; sinon, c'est l'attention GQA qui est utilisée. Lors de la conversion d'un checkpoint multi-têtes vers un checkpoint GQA, chaque tête clé et valeur de groupe doit être construite en effectuant la moyenne (meanpooling) de toutes les têtes d'origine appartenant à ce groupe. Pour plus de détails, consultez [cet article](https://huggingface.co/papers/2305.13245). S'il n'est pas spécifié, la valeur par défaut est `num_attention_heads`.

hidden_act (`str`, *facultatif*, par défaut `silu`) : La fonction d'activation non linéaire (fonction ou chaîne de caractères) dans le décodeur. Par exemple, `"gelu"`, `"relu"`, `"silu"`, etc.

max_position_embeddings (`int`, *facultatif*, valeur par défaut `32768`) : La longueur de séquence maximale avec laquelle ce modèle pourrait être utilisé.

initializer_range (`float`, *facultatif*, valeur par défaut `0.02`) : L'écart-type de la truncated_normal_initializer utilisé pour l'initialisation de toutes les matrices de poids.

rms_norm_eps (`float`, *facultatif*, valeur par défaut `1e-06`) : L'épsilon utilisé par les couches de normalisation rms.

use_cache (`bool`, *facultatif*, valeur par défaut `True`) : Indique si le modèle doit retourner les dernières attentions clés/valeurs (non utilisé par tous les modèles). Pertinent uniquement si `config.is_decoder=True` ou si le modèle est un modèle génératif de type décodeur uniquement.

rope_parameters (`Union[~modeling_rope_utils.RopeParameters, dict]`, *facultatif*) : Dictionnaire contenant les paramètres de configuration pour les embeddings RoPE. Le dictionnaire doit contenir une valeur pour `rope_theta` et, le cas échéant, les paramètres utilisés pour le mise à l'échelle si vous souhaitez utiliser RoPE avec des `max_position_embeddings` plus longs.

use_sliding_window (`bool`, *facultatif*, par défaut `False`) : Indique s'il faut utiliser l'attention à fenêtre glissante.

sliding_window (`int`, *facultatif*, valeur par défaut `32768`) : Taille de la fenêtre de l'attention à fenêtre glissante. Si `None`, aucune fenêtre glissante n'est appliquée.

max_window_layers (`int`, *facultatif*, valeur par défaut `28`) : Le nombre de couches utilisant l'attention complète. Les `max_window_layers` premières couches utiliseront l'attention complète, tandis que toute couche supplémentaire qui suivra utilisera le SWA (Sliding Window Attention).

layer_types (`list[str]`, *facultatif*) : Une liste qui associe explicitement chaque index de couche à son type de couche. S'il n'est pas fourni, il sera généré automatiquement en fonction des valeurs de configuration.

attention_dropout (`Union[float, int]`, *facultatif*, valeur par défaut `0.0`) : Le taux de dropout appliqué aux probabilités d'attention.

pad_token_id (`int`, *facultatif*) : Identifiant de jeton utilisé pour le bourrage dans le vocabulaire.

bos_token_id (`int`, *facultatif*) : Identifiant de jeton utilisé pour le début de flux dans le vocabulaire.

eos_token_id (`Union[int, list[int]]`, *facultatif*) : Identifiant de jeton utilisé pour la fin de flux dans le vocabulaire.

tie_word_embeddings (`bool`, *facultatif*, valeur par défaut `True`) : Indique s'il faut lier les embeddings de poids selon la correspondance `tied_weights_keys` du modèle.

Il s'agit de la classe de configuration destinée à stocker la configuration d'un modèle Qwen2 5 OmniModel. Elle est utilisée pour instancier un modèle Qwen2 5 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 [Qwen/Qwen2.5-Omni-7B](https://huggingface.co/Qwen/Qwen2.5-Omni-7B)

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.

Exemple :

```python
>>> from transformers import Qwen2_5OmniThinkerForConditionalGeneration, Qwen2_5OmniThinkerConfig, Qwen2_5OmniAudioEncoderConfig, Qwen2_5OmniVisionEncoderConfig

>>> # Initializing a Qwen2_5OmniAudioEncoder config
>>> audio_config = Qwen2_5OmniAudioEncoderConfig()

>>> # Initializing a Qwen2_5OmniVisionEncoder config
>>> vision_config = Qwen2_5OmniVisionEncoderConfig()

>>> # Initializing a Qwen2.5OmniThinker configuration
>>> configuration = Qwen2_5OmniThinkerConfig(audio_config, vision_config)

>>> # Initializing a model from the Qwen-Omni style configuration
>>> model = Qwen2_5OmniThinkerForConditionalGeneration(configuration)

>>> # Accessing the model configuration
>>> configuration = model.config
```

## Qwen2_5OmniDiTConfig[[transformers.Qwen2_5OmniDiTConfig]]

#### transformers.Qwen2_5OmniDiTConfig[[transformers.Qwen2_5OmniDiTConfig]]

```python
transformers.Qwen2_5OmniDiTConfig(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, hidden_size: int = 1024, num_hidden_layers: int = 22, num_attention_heads: int = 16, ff_mult: int = 2, emb_dim: int = 512, head_dim: int = 64, rope_parameters: transformers.modeling_rope_utils.RopeParameters | dict | None = None, max_position_embeddings: int = 32768, block_size: int = 24, look_ahead_layers: list[int] | tuple[int, ...] = (10,), look_backward_layers: list[int] | tuple[int, ...] = (0, 20), repeats: int = 2, num_embeds: int = 8193, mel_dim: int = 80, dropout: float | int = 0.1, enc_emb_dim: int = 192, enc_dim: int = 128, enc_channels: list[int] | tuple[int, ...] = (256, 256, 256, 256, 768), enc_kernel_sizes: list[int] | tuple[int, ...] = (5, 3, 3, 3, 1), enc_dilations: list[int] | tuple[int, ...] = (1, 2, 3, 4, 1), enc_attention_channels: int = 64, enc_res2net_scale: int = 2, enc_se_channels: int = 64)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/qwen2_5_omni/configuration_qwen2_5_omni.py#L391)

**Paramètres :**

hidden_size (`int`, *facultatif*, valeur par défaut `1024`) : Dimension des représentations cachées.

num_hidden_layers (`int`, *facultatif*, par défaut `22`) : Nombre de couches cachées dans le décodeur Transformer.

num_attention_heads (`int`, *facultatif*, valeur par défaut `16`) : Nombre de têtes d'attention pour chaque couche d'attention du décodeur Transformer.

ff_mult (`int`, *facultatif*, valeur par défaut : 2) : Le multiplicateur de la couche feedforward dans chaque bloc transformer.

emb_dim (`int`, *facultatif*, valeur par défaut 512) : La dimension de la couche d'embedding.

head_dim (`int`, *facultatif*, par défaut `64`) : La dimension des têtes d'attention. Si None, elle est par défaut égale à hidden_size // num_attention_heads

rope_parameters (`Union[~modeling_rope_utils.RopeParameters, dict]`, *facultatif*) : Dictionnaire contenant les paramètres de configuration pour les embeddings RoPE. Le dictionnaire doit contenir une valeur pour `rope_theta` et, le cas échéant, les paramètres utilisés pour le mise à l'échelle si vous souhaitez utiliser RoPE avec des `max_position_embeddings` plus longs.

max_position_embeddings (`int`, *facultatif*, valeur par défaut `32768`) : La longueur de séquence maximale avec laquelle ce modèle pourrait être utilisé.

block_size (`int`, *facultatif*, valeur par défaut : 64) : Nombre de jetons (images) dans chaque bloc de traitement.

look_ahead_layers (`list[int]`, *facultatif*, valeur par défaut `[10]`) : Nombre de couches de transformer autorisées à prendre en compte les blocs futurs

look_backward_layers (`list[int]`, *facultatif*, valeur par défaut `[0, 20]`) : Nombre de couches de transformer qui prennent en compte les blocs passés au-delà de la limite du bloc actuel

repeats (`int`, *facultatif*, par défaut 2) : Le nombre de fois que les embeddings du codec sont répétés.

num_embeds (`int`, *facultatif*, valeur par défaut 8193) : Le nombre d'embeddings uniques dans le codec.

mel_dim (`int`, *facultatif*, valeur par défaut 80) : La dimension du spectrogramme de Mel.

dropout (`Union[float, int]`, *facultatif*, valeur par défaut `0.1`) : Le ratio pour toutes les couches de dropout.

enc_emb_dim (`int`, *facultatif*, valeur par défaut 192) : La dimension de l'embedding de locuteur pré-entraîné.

enc_dim (`int`, *facultatif*, par défaut 128) : La dimension de la sortie de l'encodeur.

enc_channels (`list[int]`, *facultatif*, par défaut `[256, 256, 256, 256, 768]`) : Une liste des canaux de sortie pour chaque couche TDNN/SERes2Net de l'encodeur.

enc_kernel_sizes (`list[int]`, *facultatif*, par défaut `[5, 3, 3, 3, 1]`) : Une liste des tailles de noyau pour chaque couche de l'encodeur.

enc_dilations (`list[int]`, *facultatif*, par défaut `[1, 2, 3, 4, 1]`) : Une liste de dilatations pour chaque couche de l'encodeur.

enc_attention_channels (`int`, *facultatif*, valeur par défaut : 64) : Le nombre de canaux d'attention dans le SqueezeExcitationBlock.

enc_res2net_scale (`int`, *facultatif*, valeur par défaut : 2) : L'échelle du bloc Res2Net dans l'encodeur.

enc_se_channels (`int`, *facultatif*, par défaut 64) : Le nombre de canaux de sortie après le squeeze dans le SqueezeExcitationBlock.

Il s'agit de la classe de configuration destinée à stocker la configuration d'un modèle Qwen2 5 OmniModel. Elle est utilisée pour instancier un modèle Qwen2 5 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 [Qwen/Qwen2.5-Omni-7B](https://huggingface.co/Qwen/Qwen2.5-Omni-7B)

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.

## Qwen2_5OmniBigVGANConfig[[transformers.Qwen2_5OmniBigVGANConfig]]

#### transformers.Qwen2_5OmniBigVGANConfig[[transformers.Qwen2_5OmniBigVGANConfig]]

```python
transformers.Qwen2_5OmniBigVGANConfig(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, mel_dim: int = 80, upsample_initial_channel: int = 1536, resblock_kernel_sizes: list[int] | tuple[int, ...] = (3, 7, 11), resblock_dilation_sizes: list | tuple = ((1, 3, 5), (1, 3, 5), (1, 3, 5)), upsample_rates: list[int] | tuple[int, ...] = (5, 3, 2, 2, 2, 2), upsample_kernel_sizes: list[int] | tuple[int, ...] = (11, 7, 4, 4, 4, 4))
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/qwen2_5_omni/configuration_qwen2_5_omni.py#L456)

**Paramètres :**

mel_dim (`int`, *facultatif*, valeur par défaut 80) : La dimension du spectrogramme de Mel.

upsample_initial_channel (`int`, *facultatif*, par défaut 1536) : Le nombre de canaux dans la couche de suréchantillonnage initiale.

resblock_kernel_sizes (`list[int]`, *facultatif*, par défaut `[3, 7, 11]`) : Une liste de tailles de noyau pour chaque bloc résiduel.

resblock_dilation_sizes (`list[list[int]]`, *facultatif*, par défaut `[[1, 3, 5], [1, 3, 5], [1, 3, 5]]`) : Une liste des tailles de dilatation pour chaque bloc résiduel.

upsample_rates (`list[int]`, *facultatif*, par défaut `[5, 3, 2, 2, 2, 2]`) : Une liste des taux de suréchantillonnage pour chaque couche de suréchantillonnage.

upsample_kernel_sizes (`list[int]`, *facultatif*, par défaut `[11, 7, 4, 4, 4, 4]`) : Une liste de tailles de noyau pour chaque couche de suréchantillonnage.

Il s'agit de la classe de configuration destinée à stocker la configuration d'un modèle Qwen2 5 OmniModel. Elle est utilisée pour instancier un modèle Qwen2 5 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 [Qwen/Qwen2.5-Omni-7B](https://huggingface.co/Qwen/Qwen2.5-Omni-7B)

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.

## Qwen2_5OmniAudioEncoderConfig[[transformers.Qwen2_5OmniAudioEncoderConfig]]

#### transformers.Qwen2_5OmniAudioEncoderConfig[[transformers.Qwen2_5OmniAudioEncoderConfig]]

```python
transformers.Qwen2_5OmniAudioEncoderConfig(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, num_mel_bins: int = 128, encoder_layers: int = 32, encoder_attention_heads: int = 20, encoder_ffn_dim: int = 5120, d_model: int = 1280, dropout: float | int = 0.0, attention_dropout: float | int = 0.0, activation_function: str = 'gelu', activation_dropout: float | int = 0.0, scale_embedding: bool = False, initializer_range: float = 0.02, max_source_positions: int = 1500, n_window: int = 100, output_dim: int = 3584)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/qwen2_5_omni/configuration_qwen2_5_omni.py#L77)

**Paramètres :**

num_mel_bins (`int`, *facultatif*, valeur par défaut `128`) : Nombre de caractéristiques mel utilisées par trame d'entrée. Doit correspondre à la valeur utilisée dans la classe `AutoFeatureExtractor`.

encoder_layers (`int`, *facultatif*, valeur par défaut `32`) : Nombre de couches cachées dans l'encodeur Transformer. Utilise la même valeur que `num_layers` si non défini.

encoder_attention_heads (`int`, *facultatif*, valeur par défaut `20`) : Nombre de têtes d'attention pour chaque couche d'attention dans l'encodeur Transformer.

encoder_ffn_dim (`int`, *facultatif*, par défaut `5120`) : Dimension de la couche « intermédiaire » (souvent appelée couche feed-forward) dans l'encodeur.

d_model (`int`, *facultatif*, par défaut `1280`) : Taille des couches d'encodeur et de la couche pooler.

dropout (`Union[float, int]`, *facultatif*, valeur par défaut `0.0`) : Le ratio pour toutes les couches de dropout.

attention_dropout (`Union[float, int]`, *facultatif*, valeur par défaut `0.0`) : Le taux de dropout appliqué aux probabilités d'attention.

activation_function (`str`, *facultatif*, par défaut `gelu`) : La fonction d'activation non linéaire (fonction ou chaîne de caractères) dans le décodeur. Par exemple, `"gelu"`, `"relu"`, `"silu"`, etc.

activation_dropout (`Union[float, int]`, *facultatif*, valeur par défaut `0.0`) : Le taux de dropout pour les activations à l'intérieur de la couche entièrement connectée.

scale_embedding (`bool`, *facultatif*, valeur par défaut `False`) : Indique s'il faut mettre les embeddings à l'échelle en les divisant par sqrt(d_model).

initializer_range (`float`, *facultatif*, valeur par défaut `0.02`) : L'écart-type de la truncated_normal_initializer utilisé pour l'initialisation de toutes les matrices de poids.

max_source_positions (`int`, *facultatif*, valeur par défaut 1500) : La longueur de séquence maximale des caractéristiques de filtres log-mel avec laquelle ce modèle pourrait être utilisé.

n_window (`int`, *facultatif*, valeur par défaut : 100) : La taille des blocs pour conv et flash attn dans AudioEncoder.

output_dim (`int`, *facultatif*, valeur par défaut 3584) : La dimension de sortie de AudioEncoder.

Il s'agit de la classe de configuration destinée à stocker la configuration d'un modèle Qwen2 5 OmniModel. Elle est utilisée pour instancier un modèle Qwen2 5 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 [Qwen/Qwen2.5-Omni-7B](https://huggingface.co/Qwen/Qwen2.5-Omni-7B)

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.

Exemple :

```python
>>> from transformers import Qwen2_5OmniAudioEncoderConfig, Qwen2_5OmniAudioEncoder

>>> # Initializing a Qwen2_5OmniAudioEncoderConfig
>>> configuration = Qwen2_5OmniAudioEncoderConfig()

>>> # Initializing a Qwen2_5OmniAudioEncoder (with random weights)
>>> model = Qwen2_5OmniAudioEncoder(configuration)

>>> # Accessing the model configuration
>>> configuration = model.config
```

## Qwen2_5OmniProcessor[[transformers.Qwen2_5OmniProcessor]]

#### transformers.Qwen2_5OmniProcessor[[transformers.Qwen2_5OmniProcessor]]

```python
transformers.Qwen2_5OmniProcessor(image_processor = None, video_processor = None, feature_extractor = None, tokenizer = None, chat_template = None)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/qwen2_5_omni/processing_qwen2_5_omni.py#L121)

**Paramètres :**

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

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

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

tokenizer (`Qwen2Tokenizer`) : le tokenizer 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.

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

[Qwen2_5OmniProcessor](/docs/transformers/v5.23.0/fr/model_doc/qwen2_5_omni#transformers.Qwen2_5OmniProcessor) offre toutes les fonctionnalités de [Qwen2VLImageProcessor](/docs/transformers/v5.23.0/fr/model_doc/qwen2_vl#transformers.Qwen2VLImageProcessor), [Qwen2VLVideoProcessor](/docs/transformers/v5.23.0/fr/model_doc/qwen2_vl#transformers.Qwen2VLVideoProcessor), [WhisperFeatureExtractor](/docs/transformers/v5.23.0/fr/model_doc/whisper#transformers.WhisperFeatureExtractor) et [Qwen2Tokenizer](/docs/transformers/v5.23.0/fr/model_doc/qwen2#transformers.Qwen2Tokenizer). Consultez [~Qwen2VLImageProcessor](/docs/transformers/v5.23.0/fr/model_doc/qwen2_vl#transformers.Qwen2VLImageProcessor), [~Qwen2VLVideoProcessor](/docs/transformers/v5.23.0/fr/model_doc/qwen2_vl#transformers.Qwen2VLVideoProcessor), [~WhisperFeatureExtractor](/docs/transformers/v5.23.0/fr/model_doc/whisper#transformers.WhisperFeatureExtractor) et [~Qwen2Tokenizer](/docs/transformers/v5.23.0/fr/model_doc/qwen2#transformers.Qwen2Tokenizer) pour plus d’informations.

#### __appel__[[transformers.Qwen2_5OmniProcessor.__call__]]

```python
__call__(text: str | list[str] | list[list[str]] = None, images: typing.Union[ForwardRef('PIL.Image.Image'), numpy.ndarray, ForwardRef('torch.Tensor'), list['PIL.Image.Image'], list[numpy.ndarray], list['torch.Tensor'], NoneType] = None, videos: typing.Union[list['PIL.Image.Image'], numpy.ndarray, ForwardRef('torch.Tensor'), list[numpy.ndarray], list['torch.Tensor'], list[list['PIL.Image.Image']], list[list[numpy.ndarray]], list[list['torch.Tensor']], transformers.video_utils.URL, list[transformers.video_utils.URL], list[list[transformers.video_utils.URL]], transformers.video_utils.Path, list[transformers.video_utils.Path], list[list[transformers.video_utils.Path]], NoneType] = None, audio: typing.Union[numpy.ndarray, ForwardRef('torch.Tensor'), list[numpy.ndarray], list['torch.Tensor'], NoneType] = None, **kwargs: *<class 'transformers.models.qwen2_5_omni.processing_qwen2_5_omni.Qwen2_5OmniProcessorKwargs'>)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/qwen2_5_omni/processing_qwen2_5_omni.py#L155)

**Paramètres :**

text (`Union[str, list[str], list[list[str]]]`, *facultatif*) : La séquence ou le lot de séquences à encoder. Chaque séquence peut être une chaîne de caractères ou une liste de chaînes (chaîne pré-tokenisée). Si vous transmettez une entrée pré-tokenisée, définissez `is_split_into_words=True` pour éviter toute ambiguïté avec les entrées en lot.

images (`Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor]]`, *facultatif*) : Image à prétraiter. Attend une image unique ou un lot d'images dont les valeurs de pixels sont comprises entre 0 et 255. Si vous transmettez des images dont les valeurs de pixels sont comprises entre 0 et 1, définissez `do_rescale=False`.

videos (`Union[list[PIL.Image.Image], numpy.ndarray, torch.Tensor, list[numpy.ndarray], list[torch.Tensor], list[list[PIL.Image.Image]], list[list[numpy.ndarray]], list[list[torch.Tensor]], ~video_utils.URL, list[~video_utils.URL], list[list[~video_utils.URL]], ~video_utils.Path, list[~video_utils.Path], list[list[~video_utils.Path]]]`, *facultatif*) : Vidéo à prétraiter. S'attend à une vidéo unique ou à un lot de vidéos dont les valeurs de pixels sont comprises entre 0 et 255. Si vous transmettez des vidéos dont les valeurs de pixels sont comprises entre 0 et 1, définissez `do_rescale=False`.

audio (`Union[numpy.ndarray, torch.Tensor, list[numpy.ndarray], list[torch.Tensor]]`, *facultatif*) : L'audio ou le lot d'audios à préparer. Chaque audio peut être un tableau NumPy ou un tenseur PyTorch. Dans le cas d'un tableau NumPy/d'un tenseur PyTorch, chaque audio doit avoir la forme (C, T), où C est le nombre de canaux et T est la longueur d'échantillonnage de l'audio.

min_pixels (`int`, *kwargs*, *facultatif*) : Nombre minimal de pixels (hauteur × largeur) pour les images vidéo après redimensionnement. Les images inférieures à ce seuil seront agrandies pour respecter la exigence minimale.

max_pixels (`int`, *kwargs*, *facultatif*) : Nombre maximal de pixels (hauteur × largeur) pour les images vidéo après redimensionnement. Les images dépassant ce seuil seront réduites pour respecter la limite.

patch_size (`int`, *kwargs*, *facultatif*) : La taille des patches spatiaux utilisée par l'encodeur visuel. Les images vidéo sont divisées en patches de cette taille dans les dimensions de hauteur et de largeur.

temporal_patch_size (`int`, *kwargs*, *facultatif*) : La taille de la trame temporelle utilisée par l'encodeur visuel. Elle détermine le nombre de frames consécutives regroupées en une seule trame temporelle.

merge_size (`int`, *kwargs*, *facultatif*) : La taille de fusion utilisée pour combiner les patches spatiaux. Plusieurs patches sont fusionnés ensemble afin de réduire la longueur de la séquence tout en conservant les informations spatiales.

min_frames (`int`, *kwargs*, *facultatif*) : Nombre minimal d'images à extraire de la vidéo. Les vidéos contenant moins d'images seront rembourdées ou répétées pour satisfaire cette exigence.

max_frames (`int`, *kwargs*, *facultatif*) : Nombre maximal de frames à extraire de la vidéo. Les vidéos plus longues seront tronquées ou échantillonnées pour respecter cette limite.

use_audio_in_video (`bool`, *kwargs*, *facultatif*, valeur par défaut `False`) : argument obsolète - utilisez `load_audio_from_video` à la place.

load_audio_from_video (`bool`, *kwargs*, *facultatif*, valeur par défaut `False`) : Obsolète, utilisez `Qwen2_5OmniProcessorKwargs.load_audio_from_video` à la place. Indique s'il faut intégrer les informations audio lors du traitement des vidéos. Si activé, les jetons audio sont entrelacés avec les jetons vidéo en fonction de l'alignement temporel, créant ainsi une représentation multimodale unifiée.

seconds_per_chunk (`float`, *kwargs*, *facultatif*, valeur par défaut `2.0`) : Obsolète, utilisez `Qwen2_5OmniProcessorKwargs.seconds_per_chunk` à la place. La durée (en secondes) de chaque segment de vidéo lors du découpage des vidéos longues. Ce paramètre contrôle la manière dont les vidéos sont divisées en segments temporels pour le traitement.

position_id_per_seconds (`int`, *kwargs* ou `float`, *facultatif*, valeur par défaut `25`) : Obsolète, utilisez `Qwen2_5OmniProcessorKwargs.position_id_per_seconds` à la place. Le nombre d'identifiants de position alloués par seconde de vidéo. Ce paramètre contrôle la résolution temporelle des embeddings de position et est utilisé pour aligner les jetons vidéo avec les jetons audio lorsque `use_audio_in_video=True`.

return_mm_token_type_ids (`bool`, *kwargs*) : Indique s'il faut retourner les identifiants de type de jeton multimodal indiquant les positions des jetons de substitution multimodaux.

return_text_replacement_offsets (`bool`, *kwargs*) : Indique s'il faut retourner les décalages de caractères pour chaque emplacement multimodal et son remplacement.

load_audio_from_video (`bool`, *kwargs*) : Indique s'il faut charger la piste audio des vidéos d'entrée. Les jetons audio sont entrelacés avec les jetons vidéo si le modèle le prend en charge.

seconds_per_chunk (`float`, *kwargs*, *facultatif*, valeur par défaut `2.0`) : La durée (en secondes) de chaque segment de vidéo lors du découpage des vidéos longues. Ce paramètre contrôle la manière dont les vidéos sont divisées en segments temporels pour le traitement.

position_id_per_seconds (`int`, *kwargs* ou `float`, *facultatif*, valeur par défaut `25`) : Le nombre d'identifiants de position alloués par seconde de vidéo. Ce paramètre contrôle la résolution temporelle des embeddings de position et est utilisé pour aligner les jetons vidéo avec les jetons audio lorsque `load_audio_from_video=True`.

return_tensors (`str` ou [TensorType](/docs/transformers/v5.23.0/fr/internal/file_utils#transformers.TensorType), *facultatif*) : Si défini, renverra des tenseurs d'un framework particulier. Les valeurs acceptables sont :  - `'pt'` : Renvoie des objets `torch.Tensor` de PyTorch. - `'np'` : Renvoie des objets `np.ndarray` de NumPy.

- ****kwargs** ([ProcessingKwargs](/docs/transformers/v5.23.0/fr/main_classes/processors#transformers.ProcessingKwargs), *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.

**Retourne :** `~feature_extraction_utils.BatchFeature`

- **data** (`dict`, *facultatif*) -- Dictionnaire de listes/tableaux/tenseurs renvoyé par les méthodes __call__/pad (« input_values », « attention_mask », 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.
- **skip_tensor_conversion** (`list[str]` ou `set[str]`, *facultatif*) -- Liste ou ensemble de clés qui ne doivent PAS être converties en tenseurs, même lorsque `tensor_type` est spécifié.

## Qwen2_5OmniForConditionalGeneration[[transformers.Qwen2_5OmniForConditionalGeneration]]

#### transformers.Qwen2_5OmniForConditionalGeneration[[transformers.Qwen2_5OmniForConditionalGeneration]]

```python
transformers.Qwen2_5OmniForConditionalGeneration(config: Qwen2_5OmniConfig)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/qwen2_5_omni/modeling_qwen2_5_omni.py#L3715)

**Paramètres :**

config ([Qwen2_5OmniConfig](/docs/transformers/v5.23.0/fr/model_doc/qwen2_5_omni#transformers.Qwen2_5OmniConfig)) : Classe de configuration du modèle contenant tous les paramètres du modèle. L'initialisation à partir d'un fichier de configuration ne charge pas les poids associés au modèle, uniquement la configuration. Consultez la méthode [from_pretrained()](/docs/transformers/v5.23.0/fr/main_classes/model#transformers.PreTrainedModel.from_pretrained) pour charger les poids du modèle.

Le modèle complet Qwen2.5Omni, un modèle multimodal composé de 3 sous-modèles :
- [Qwen2_5OmniThinkerForConditionalGeneration](/docs/transformers/v5.23.0/fr/model_doc/qwen2_5_omni#transformers.Qwen2_5OmniThinkerForConditionalGeneration) :
Un transformateur auto-régressif causal prend en entrée du texte, de l'audio, des images ou de la vidéo, et prédit des jetons de texte.
- [Qwen2_5OmniTalkerForConditionalGeneration](/docs/transformers/v5.23.0/fr/model_doc/qwen2_5_omni#transformers.Qwen2_5OmniTalkerForConditionalGeneration) :
Un transformateur auto-régressif causal prend en entrée les états cachés du penseur et la réponse, et prédit les jetons de parole.
- [Qwen2_5OmniToken2WavModel](/docs/transformers/v5.23.0/fr/model_doc/qwen2_5_omni#transformers.Qwen2_5OmniToken2WavModel) :
Un modèle DiT prend des jetons de parole en entrée et prédit un spectrogramme mel, tandis qu'un vocodeur BigVGAN prend un spectrogramme mel en entrée et prédit une forme d'onde.

Ce modèle hérite de [PreTrainedModel](/docs/transformers/v5.23.0/fr/main_classes/model#transformers.PreTrainedModel). Consultez la documentation de la classe parente pour les méthodes génériques que la bibliothèque implémente pour tous ses modèles (tels que le téléchargement ou l'enregistrement, le redimensionnement des embeddings d'entrée, l'élagage des têtes, etc.).

Ce modèle est également une sous-classe de [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) de PyTorch. Utilisez-le comme un module PyTorch standard et consultez la documentation de PyTorch pour tout ce qui concerne l’utilisation et le comportement généraux.

#### forward[[transformers.Qwen2_5OmniForConditionalGeneration.forward]]

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

Une valeur factice pour un chemin pointé (par ex. `torch.float32`) : les chaînes d'accès aux attributs et les appels se comportent comme des décorateurs de pass-through, `repr` est le chemin pointé, et son utilisation comme classe de base substitue une base de `type` ordinaire (PEP 560 `__mro_entries__`), de sorte que les vraies sous-classes conservent un métaclasse normal et que `inspect.signature` lit leur `__init__` réel plutôt que celui d'une valeur factice.

## Qwen2_5OmniPreTrainedModelForConditionalGeneration[[transformers.Qwen2_5OmniPreTrainedModelForConditionalGeneration]]

#### transformers.Qwen2_5OmniPreTrainedModelForConditionalGeneration[[transformers.Qwen2_5OmniPreTrainedModelForConditionalGeneration]]

```python
transformers.Qwen2_5OmniPreTrainedModelForConditionalGeneration(config: PreTrainedConfig, *inputs, **kwargs)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/qwen2_5_omni/modeling_qwen2_5_omni.py#L155)

#### get_chunked_index[[transformers.Qwen2_5OmniPreTrainedModelForConditionalGeneration.get_chunked_index]]

```python
get_chunked_index(token_indices: Tensor, tokens_per_chunk: int, remove_index: int)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/qwen2_5_omni/modeling_qwen2_5_omni.py#L178)

**Paramètres :**

token_indices (`torch.Tensor` de forme `(seq_len, )`) : Liste d'indices de jetons en augmentation monotone.

t_ntoken_per_chunk (`int`) : Nombre de jetons par bloc (utilisé comme seuil de taille de bloc).

remove_index (`int`) Un identifiant d'index à soustraire de `token_indices` avant le fractionnement --

**Retourne :** `list[tuple[int, int]]`

Une liste de tuples, chacun représentant les indices de début (inclus) et de fin (exclus) d'un fragment dans `token_indices`.

Divise la liste d'indices de jetons en segments en fonction des plages de valeurs des jetons.

Étant donné une liste d’indices de jetons, renvoie une liste de tuples d’indices (début, fin) représentant des tranches de la liste où les valeurs des jetons se situent dans des plages successives de `t_ntoken_per_chunk`.

Par exemple, si `t_ntoken_per_chunk` vaut 1000, la fonction créera des blocs tels que :
- le premier bloc contient des valeurs de jetons < 1000,
- le deuxième bloc contient des valeurs >= 1000 et < 2000, et ainsi de suite.

#### get_rope_index[[transformers.Qwen2_5OmniPreTrainedModelForConditionalGeneration.get_rope_index]]

```python
get_rope_index(input_ids: typing.Optional[torch.LongTensor] = None, image_grid_thw: typing.Optional[torch.LongTensor] = None, video_grid_thw: typing.Optional[torch.LongTensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, use_audio_in_video: bool = False, audio_seqlens: typing.Optional[torch.LongTensor] = None, second_per_grids: typing.Optional[torch.Tensor] = None)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/qwen2_5_omni/modeling_qwen2_5_omni.py#L215)

**Paramètres :**

input_ids (`torch.LongTensor` de forme `(batch_size, sequence_length)`) : Indices des jetons de la séquence d'entrée dans le vocabulaire. Le bourrage (padding) sera ignoré par défaut si vous le fournissez.

image_grid_thw (`torch.LongTensor` de forme `(num_images, 3)`, *facultatif*) : La dimension temporelle, la hauteur et la largeur de la forme des caractéristiques de chaque image dans le LLM.

video_grid_thw (`torch.LongTensor` de forme `(num_videos, 3)`, *facultatif*) : La dimension temporelle, la hauteur et la largeur de la forme des caractéristiques de chaque vidéo dans le LLM.

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**.

use_audio_in_video (`bool`, *facultatif*) : Si défini sur `True`, utilise l'audio de la vidéo.

audio_seqlens (`torch.LongTensor` de forme `(num_audios)`, *facultatif*) : La longueur de la forme des caractéristiques de chaque audio dans le LLM.

second_per_grids (`torch.LongTensor` de forme `(num_videos)`, *facultatif*) : L'intervalle de temps (en secondes) pour chaque grille le long de la dimension temporelle dans les identifiants de position 3D.

**Retourne :**

position_ids (`torch.LongTensor` de forme `(3, batch_size, sequence_length)`) mrope_position_deltas (`torch.Tensor` de forme `(batch_size)`)

Calculer l'index rope 3D en fonction des dimensions temporelle, de hauteur et de largeur de l'image et de la vidéo dans le LLM.

Explication : chaque séquence d’embeddings contient un embedding visuel et un embedding textuel, ou uniquement un embedding textuel.

Pour une séquence d’encodage de texte pur, l’encodage de position rotatif ne présente aucune différence par rapport aux LLM modernes. Exemples : input_ids : [T T T T T], où T désigne le texte. position_ids temporels : [0, 1, 2, 3, 4] position_ids en hauteur : [0, 1, 2, 3, 4] position_ids en largeur : [0, 1, 2, 3, 4]

Pour la séquence d'embeddings de vision et de texte, nous calculons un embedding de position rotatif 3D pour la partie vision et un embedding de position rotatif 1D pour la partie texte. Exemples : Temporel (Temps) : 3 patches, représentant différents segments de la vidéo dans le temps. Hauteur : 2 patches, divisant chaque frame verticalement. Largeur : 2 patches, divisant chaque frame horizontalement. Nous avons également certains paramètres importants : fps (Frames Per Second) : le taux de frames de la vidéo, défini à 1. Cela signifie qu'une frame est traitée chaque seconde. tokens_per_second : c'est un paramètre crucial. Il détermine le nombre de « time-steps » ou « tokens temporels » conceptuellement regroupés dans un intervalle d'une seconde de la vidéo. Dans ce cas, nous avons 25 tokens par seconde. Ainsi, chaque seconde de la vidéo sera représentée par 25 points temporels distincts. Il définit essentiellement la granularité temporelle. temporal_patch_size : le nombre de frames qui composent un patch temporel. Ici, il s'agit de 2 frames. interval : la taille du pas pour les IDs de position temporelle, calculée comme tokens_per_second * temporal_patch_size / fps. Dans ce cas, 25 * 2 / 1 = 50. Cela signifie que chaque patch temporel aura une différence de 50 dans les IDs de position temporelle. input_ids : [V V V V V V V V V V V V T T T T T], où V désigne la vision. vision temporal position_ids : [0, 0, 0, 0, 50, 50, 50, 50, 100, 100, 100, 100] vision height position_ids : [0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1] vision width position_ids : [0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1] text temporal position_ids : [101, 102, 103, 104, 105] text height position_ids : [101, 102, 103, 104, 105] text width position_ids : [101, 102, 103, 104, 105] Ici, nous calculons les position_ids de début du texte comme le maximum des position_ids de vision plus 1.

## Qwen2_5OmniThinkerConfig[[transformers.Qwen2_5OmniThinkerConfig]]

#### transformers.Qwen2_5OmniThinkerConfig[[transformers.Qwen2_5OmniThinkerConfig]]

```python
transformers.Qwen2_5OmniThinkerConfig(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, audio_config: dict | transformers.configuration_utils.PreTrainedConfig | None = None, vision_config: dict | transformers.configuration_utils.PreTrainedConfig | None = None, text_config: dict | transformers.configuration_utils.PreTrainedConfig | None = None, audio_token_index: int = 151646, image_token_index: int = 151655, video_token_index: int = 151656, position_id_per_seconds: int = 25, seconds_per_chunk: int = 2, audio_start_token_id: int = 151647, audio_end_token_id: int = 151648, user_token_id: int = 872, initializer_range: float = 0.02, tie_word_embeddings: bool = False)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/qwen2_5_omni/configuration_qwen2_5_omni.py#L212)

**Paramètres :**

audio_config (`Union[dict, ~configuration_utils.PreTrainedConfig]`, *facultatif*) : L'objet de configuration ou le dictionnaire du backbone audio.

vision_config (`Union[dict, ~configuration_utils.PreTrainedConfig]`, *facultatif*) : L'objet de configuration ou le dictionnaire du backbone visuel.

text_config (`Union[dict, ~configuration_utils.PreTrainedConfig]`, *facultatif*) : L'objet de configuration ou le dictionnaire du backbone de texte.

audio_token_index (`int`, *facultatif*, valeur par défaut `151646`) : L'index du jeton audio utilisé comme espace réservé pour l'audio d'entrée.

image_token_index (`int`, *facultatif*, valeur par défaut `151655`) : L'index du jeton d'image utilisé comme espace réservé pour les images d'entrée.

video_token_index (`int`, *facultatif*, valeur par défaut `151656`) : L'index du jeton vidéo utilisé comme espace réservé pour les vidéos d'entrée.

position_id_per_seconds (`int`, *facultatif*, valeur par défaut : 25) : L'incrément de l'identifiant de position par seconde.

seconds_per_chunk (`int`, *facultatif*, valeur par défaut : 2) : La durée, en secondes, de la portion de données audio et vidéo.

audio_start_token_id (`int`, *facultatif*, valeur par défaut 151647) : L'index du jeton de début d'audio à utiliser pour encoder le prompt audio.

audio_end_token_id (`int`, *facultatif*, valeur par défaut 151648) : L'index du jeton de fin d'audio à utiliser pour encoder le prompt audio.

user_token_id (`int, *optionnel*, par défaut 872) : L'index du jeton utilisateur pour encoder le jeton utilisateur.

initializer_range (`float`, *facultatif*, valeur par défaut `0.02`) : L'écart-type de la truncated_normal_initializer utilisé pour l'initialisation de toutes les matrices de poids.

tie_word_embeddings (`bool`, *facultatif*, valeur par défaut `False`) : Indique s'il faut lier les embeddings de poids selon la correspondance `tied_weights_keys` du modèle.

Il s'agit de la classe de configuration destinée à stocker la configuration d'un modèle Qwen2 5 OmniModel. Elle est utilisée pour instancier un modèle Qwen2 5 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 [Qwen/Qwen2.5-Omni-7B](https://huggingface.co/Qwen/Qwen2.5-Omni-7B)

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.

Exemple :

```python
>>> from transformers import Qwen2_5OmniThinkerForConditionalGeneration, Qwen2_5OmniThinkerConfig, Qwen2_5OmniAudioEncoderConfig, Qwen2_5OmniVisionEncoderConfig

>>> # Initializing a Qwen2_5OmniAudioEncoder config
>>> audio_config = Qwen2_5OmniAudioEncoderConfig()

>>> # Initializing a Qwen2_5OmniVisionEncoder config
>>> vision_config = Qwen2_5OmniVisionEncoderConfig()

>>> # Initializing a Qwen2_5OmniTextConfig config
>>> text_config = Qwen2_5OmniTextConfig()

>>> # Initializing a Qwen2.5OmniThinker configuration
>>> configuration = Qwen2_5OmniThinkerConfig(audio_config, vision_config, text_config)

>>> # Initializing a model from the Qwen-Omni style configuration
>>> model = Qwen2_5OmniThinkerForConditionalGeneration(configuration)

>>> # Accessing the model configuration
>>> configuration = model.config
```

## Qwen2_5OmniThinkerModel[[transformers.Qwen2_5OmniThinkerModel]]

#### transformers.Qwen2_5OmniThinkerModel[[transformers.Qwen2_5OmniThinkerModel]]

```python
transformers.Qwen2_5OmniThinkerModel(config: Qwen2_5OmniThinkerConfig)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/qwen2_5_omni/modeling_qwen2_5_omni.py#L1668)

**Paramètres :**

config ([Qwen2_5OmniThinkerConfig](/docs/transformers/v5.23.0/fr/model_doc/qwen2_5_omni#transformers.Qwen2_5OmniThinkerConfig)) : Classe de configuration du modèle contenant tous les paramètres du modèle. L'initialisation à partir d'un fichier de configuration ne charge pas les poids associés au modèle, uniquement la configuration. Consultez la méthode [from_pretrained()](/docs/transformers/v5.23.0/fr/main_classes/model#transformers.PreTrainedModel.from_pretrained) pour charger les poids du modèle.

Le modèle Qwen2.5OmniThinker, qui se compose d'un tronc audio et d'un modèle de langage.

Ce modèle hérite de [PreTrainedModel](/docs/transformers/v5.23.0/fr/main_classes/model#transformers.PreTrainedModel). Consultez la documentation de la classe parente pour les méthodes génériques que la bibliothèque implémente pour tous ses modèles (tels que le téléchargement ou l'enregistrement, le redimensionnement des embeddings d'entrée, l'élagage des têtes, etc.).

Ce modèle est également une sous-classe de [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) de PyTorch. Utilisez-le comme un module PyTorch standard et consultez la documentation de PyTorch pour tout ce qui concerne l’utilisation et le comportement généraux.

#### forward[[transformers.Qwen2_5OmniThinkerModel.forward]]

```python
forward(input_ids: typing.Optional[torch.LongTensor] = None, input_features: typing.Optional[torch.Tensor] = None, pixel_values: typing.Optional[torch.Tensor] = None, pixel_values_videos: typing.Optional[torch.Tensor] = None, image_grid_thw: typing.Optional[torch.LongTensor] = None, video_grid_thw: typing.Optional[torch.LongTensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, feature_attention_mask: typing.Optional[torch.Tensor] = None, audio_feature_lengths: typing.Optional[torch.LongTensor] = None, position_ids: typing.Optional[torch.LongTensor] = None, past_key_values: transformers.cache_utils.Cache | None = None, inputs_embeds: typing.Optional[torch.Tensor] = None, use_cache: bool | None = None, use_audio_in_video: bool | None = None, video_second_per_grid: typing.Optional[torch.LongTensor] = 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/qwen2_5_omni/modeling_qwen2_5_omni.py#L1843)

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

input_features (`torch.Tensor` de forme `(batch_size, sequence_length, feature_dim)`, *facultatif*) : Les tenseurs correspondant aux caractéristiques audio d’entrée. Les caractéristiques audio peuvent être obtenues à l’aide de [WhisperFeatureExtractor](/docs/transformers/v5.23.0/fr/model_doc/whisper#transformers.WhisperFeatureExtractor). Voir [WhisperFeatureExtractor.__call__()](/docs/transformers/v5.23.0/fr/model_doc/whisper#transformers.WhisperFeatureExtractor.__call__) pour plus de détails ([Qwen2_5OmniProcessor](/docs/transformers/v5.23.0/fr/model_doc/qwen2_5_omni#transformers.Qwen2_5OmniProcessor) utilise [WhisperFeatureExtractor](/docs/transformers/v5.23.0/fr/model_doc/whisper#transformers.WhisperFeatureExtractor) pour le traitement des audios).

pixel_values (`torch.Tensor` de forme `(batch_size, num_channels, image_size, image_size)`, *facultatif*) : Les tenseurs correspondant aux images d’entrée. Les valeurs de pixels peuvent être obtenues à l’aide de [Qwen2VLImageProcessor](/docs/transformers/v5.23.0/fr/model_doc/qwen2_vl#transformers.Qwen2VLImageProcessor). Voir [Qwen2VLImageProcessor.__call__()](/docs/transformers/v5.23.0/fr/model_doc/molmo2#transformers.Molmo2ImageProcessor.__call__) pour plus de détails ([Qwen2_5OmniProcessor](/docs/transformers/v5.23.0/fr/model_doc/qwen2_5_omni#transformers.Qwen2_5OmniProcessor) utilise [Qwen2VLImageProcessor](/docs/transformers/v5.23.0/fr/model_doc/qwen2_vl#transformers.Qwen2VLImageProcessor) pour le traitement des images).

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 [Qwen2VLVideoProcessor](/docs/transformers/v5.23.0/fr/model_doc/qwen2_vl#transformers.Qwen2VLVideoProcessor). Voir [Qwen2VLVideoProcessor.__call__()](/docs/transformers/v5.23.0/fr/model_doc/molmo2#transformers.Molmo2VideoProcessor.__call__) pour plus de détails ([Qwen2_5OmniProcessor](/docs/transformers/v5.23.0/fr/model_doc/qwen2_5_omni#transformers.Qwen2_5OmniProcessor) utilise [Qwen2VLVideoProcessor](/docs/transformers/v5.23.0/fr/model_doc/qwen2_vl#transformers.Qwen2VLVideoProcessor) pour le traitement des vidéos).

image_grid_thw (`torch.LongTensor` de forme `(num_images, 3)`, *facultatif*) : La dimension temporelle, la hauteur et la largeur de la forme des caractéristiques de chaque image dans le LLM.

video_grid_thw (`torch.LongTensor` de forme `(num_videos, 3)`, *facultatif*) : La dimension temporelle, la hauteur et la largeur de la forme des caractéristiques de chaque vidéo dans le LLM.

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)

feature_attention_mask (`torch.Tensor` de forme `(batch_size, feature_sequence_length)`, *facultatif*) : Masque pour éviter d'appliquer l'attention aux indices de caractéristiques de bourrage. Valeurs du masque sélectionnées dans `[0, 1]` : - 1 pour les jetons qui ne sont **pas masqués**, - 0 pour les jetons qui sont **masqués**.

audio_feature_lengths (`torch.LongTensor` de forme `(num_audios)`, *facultatif*) : La longueur de la forme des caractéristiques de chaque audio dans le LLM.

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

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

use_audio_in_video (`bool`, *facultatif*) : Indique s'il faut utiliser la piste audio de la vidéo. Doit être identique au paramètre de `process_audio_info`.

video_second_per_grid (`torch.LongTensor` de forme `(num_videos)`, *facultatif*) : Nombre de secondes par grille pour chaque vidéo, utilisé pour le mappage des caractéristiques temporelles.

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 :** [BaseModelOutputWithPast](/docs/transformers/v5.23.0/fr/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPast) ou `tuple(torch.Tensor)`

Un [BaseModelOutputWithPast](/docs/transformers/v5.23.0/fr/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPast) 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 ([Qwen2_5OmniConfig](/docs/transformers/v5.23.0/fr/model_doc/qwen2_5_omni#transformers.Qwen2_5OmniConfig)) et les entrées.

La méthode forward du modèle [Qwen2_5OmniThinkerModel](/docs/transformers/v5.23.0/fr/model_doc/qwen2_5_omni#transformers.Qwen2_5OmniThinkerModel) 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.

- **last_hidden_state** (`torch.Tensor` de forme `(batch_size, sequence_length, hidden_size)`) -- Séquence d'états cachés à la sortie de la dernière couche du modèle.

  Si `past_key_values` est utilisé, seule la dernière hidden-state des séquences de forme `(batch_size, 1, hidden_size)` est renvoyée.
- **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 et, le cas échéant, si `config.is_encoder_decoder=True`, dans les blocs d'attention croisée) 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.

## Qwen2_5OmniThinkerForConditionalGeneration[[transformers.Qwen2_5OmniThinkerForConditionalGeneration]]

#### transformers.Qwen2_5OmniThinkerForConditionalGeneration[[transformers.Qwen2_5OmniThinkerForConditionalGeneration]]

```python
transformers.Qwen2_5OmniThinkerForConditionalGeneration(config: Qwen2_5OmniThinkerConfig)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/qwen2_5_omni/modeling_qwen2_5_omni.py#L1959)

#### forward[[transformers.Qwen2_5OmniThinkerForConditionalGeneration.forward]]

```python
forward(input_ids: typing.Optional[torch.LongTensor] = None, input_features: typing.Optional[torch.Tensor] = None, pixel_values: typing.Optional[torch.Tensor] = None, pixel_values_videos: typing.Optional[torch.Tensor] = None, image_grid_thw: typing.Optional[torch.LongTensor] = None, video_grid_thw: typing.Optional[torch.LongTensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, feature_attention_mask: typing.Optional[torch.Tensor] = None, audio_feature_lengths: typing.Optional[torch.LongTensor] = None, position_ids: typing.Optional[torch.LongTensor] = None, past_key_values: transformers.cache_utils.Cache | None = None, inputs_embeds: typing.Optional[torch.Tensor] = None, labels: typing.Optional[torch.LongTensor] = None, use_cache: bool | None = None, use_audio_in_video: bool | None = None, video_second_per_grid: typing.Optional[torch.LongTensor] = 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/qwen2_5_omni/modeling_qwen2_5_omni.py#L2017)

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

input_features (`torch.Tensor` de forme `(batch_size, sequence_length, feature_dim)`, *facultatif*) : Les tenseurs correspondant aux caractéristiques audio d’entrée. Les caractéristiques audio peuvent être obtenues à l’aide de [WhisperFeatureExtractor](/docs/transformers/v5.23.0/fr/model_doc/whisper#transformers.WhisperFeatureExtractor). Voir [WhisperFeatureExtractor.__call__()](/docs/transformers/v5.23.0/fr/model_doc/whisper#transformers.WhisperFeatureExtractor.__call__) pour plus de détails ([Qwen2_5OmniProcessor](/docs/transformers/v5.23.0/fr/model_doc/qwen2_5_omni#transformers.Qwen2_5OmniProcessor) utilise [WhisperFeatureExtractor](/docs/transformers/v5.23.0/fr/model_doc/whisper#transformers.WhisperFeatureExtractor) pour le traitement des audios).

pixel_values (`torch.Tensor` de forme `(batch_size, num_channels, image_size, image_size)`, *facultatif*) : Les tenseurs correspondant aux images d’entrée. Les valeurs de pixels peuvent être obtenues à l’aide de [Qwen2VLImageProcessor](/docs/transformers/v5.23.0/fr/model_doc/qwen2_vl#transformers.Qwen2VLImageProcessor). Voir [Qwen2VLImageProcessor.__call__()](/docs/transformers/v5.23.0/fr/model_doc/molmo2#transformers.Molmo2ImageProcessor.__call__) pour plus de détails ([Qwen2_5OmniProcessor](/docs/transformers/v5.23.0/fr/model_doc/qwen2_5_omni#transformers.Qwen2_5OmniProcessor) utilise [Qwen2VLImageProcessor](/docs/transformers/v5.23.0/fr/model_doc/qwen2_vl#transformers.Qwen2VLImageProcessor) pour le traitement des images).

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 [Qwen2VLVideoProcessor](/docs/transformers/v5.23.0/fr/model_doc/qwen2_vl#transformers.Qwen2VLVideoProcessor). Voir [Qwen2VLVideoProcessor.__call__()](/docs/transformers/v5.23.0/fr/model_doc/molmo2#transformers.Molmo2VideoProcessor.__call__) pour plus de détails ([Qwen2_5OmniProcessor](/docs/transformers/v5.23.0/fr/model_doc/qwen2_5_omni#transformers.Qwen2_5OmniProcessor) utilise [Qwen2VLVideoProcessor](/docs/transformers/v5.23.0/fr/model_doc/qwen2_vl#transformers.Qwen2VLVideoProcessor) pour le traitement des vidéos).

image_grid_thw (`torch.LongTensor` de forme `(num_images, 3)`, *facultatif*) : La dimension temporelle, la hauteur et la largeur de la forme des caractéristiques de chaque image dans le LLM.

video_grid_thw (`torch.LongTensor` de forme `(num_videos, 3)`, *facultatif*) : La dimension temporelle, la hauteur et la largeur de la forme des caractéristiques de chaque vidéo dans le LLM.

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)

feature_attention_mask (`torch.Tensor` de forme `(batch_size, feature_sequence_length)`, *facultatif*) : Masque pour éviter d'appliquer l'attention aux indices de caractéristiques de bourrage. Valeurs du masque sélectionnées dans `[0, 1]` : - 1 pour les jetons qui ne sont **pas masqués**, - 0 pour les jetons qui sont **masqués**.

audio_feature_lengths (`torch.LongTensor` de forme `(num_audios)`, *facultatif*) : La longueur de la forme des caractéristiques de chaque audio dans le LLM.

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

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.

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]`.

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

use_audio_in_video (`bool`, *facultatif*) : Indique s'il faut utiliser la piste audio de la vidéo. Doit être identique au paramètre de `process_audio_info`.

video_second_per_grid (`torch.LongTensor` de forme `(num_videos)`, *facultatif*) : Nombre de secondes par grille pour chaque vidéo, utilisé pour le mappage des caractéristiques temporelles.

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 ([Qwen2_5OmniConfig](/docs/transformers/v5.23.0/fr/model_doc/qwen2_5_omni#transformers.Qwen2_5OmniConfig)) et les entrées.

La méthode forward de [Qwen2_5OmniThinkerForConditionalGeneration](/docs/transformers/v5.23.0/fr/model_doc/qwen2_5_omni#transformers.Qwen2_5OmniThinkerForConditionalGeneration) 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 transformers import Qwen2_5OmniProcessor, Qwen2_5OmniThinkerForConditionalGeneration

>>> thinker = Qwen2_5OmniThinkerForConditionalGeneration.from_pretrained("Qwen/Qwen2.5-Omni-7B")
>>> processor = Qwen2_5OmniProcessor.from_pretrained("Qwen/Qwen2.5-Omni-7B")

>>> conversations = [
>>>         {'role': 'system', 'content': 'You are a helpful voice chat bot, and please respond to me in a casual conversation manner using random voice.'},
>>>         {"role": "user", "content": [
>>>             {"type": "image", "image": "https://www.ilankelman.org/stopsigns/australia.jpg"},
>>>             {"type": "audio", "audio": "https://huggingface.co/datasets/hf-internal-testing/transformers-synthetic-assets/resolve/main/audio/glass_breaking.mp3"},
>>>         ]},
>>> ]

>>> inputs = processor.apply_chat_template(
    conversations,
    tokenize=True,
    add_generation_prompt=True,
    return_dict=True,
    return_tensors="pt"
)

>>> # Generate
>>> generation = thinker.generate(**inputs, max_new_tokens=2048)
>>> generate_ids = generation[:, inputs.input_ids.size(1):]

>>> response = processor.batch_decode(generate_ids, skip_special_tokens=True, clean_up_tokenization_spaces=False)[0]
```

#### get_audio_features[[transformers.Qwen2_5OmniThinkerForConditionalGeneration.get_audio_features]]

```python
get_audio_features(input_features: Tensor, feature_attention_mask: typing.Optional[torch.LongTensor] = None, audio_feature_lengths: typing.Optional[torch.LongTensor] = None, **kwargs: *<class 'transformers.utils.generic.TransformersKwargs'>)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/qwen2_5_omni/modeling_qwen2_5_omni.py#L1999)

**Paramètres :**

input_features (`torch.Tensor`) : Les tenseurs correspondant aux audios d'entrée.

feature_attention_mask (`torch.LongTensor`, *facultatif*) : Masque pour éviter d'appliquer l'attention aux indices de caractéristiques de bourrage. Les valeurs du masque sont choisies dans `[0, 1]` :

audio_feature_lengths (`torch.LongTensor` de forme `(num_audios)`, *facultatif*) : La longueur de la forme des caractéristiques de chaque audio dans le LLM.

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

Un [BaseModelOutputWithPooling](/docs/transformers/v5.23.0/fr/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPooling) 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 ([Qwen2_5OmniConfig](/docs/transformers/v5.23.0/fr/model_doc/qwen2_5_omni#transformers.Qwen2_5OmniConfig)) et les entrées.

- **last_hidden_state** (`torch.Tensor` de forme `(batch_size, sequence_length, hidden_size)`) -- Séquence d'états cachés à la sortie de la dernière couche du modèle.
- **pooler_output** (`torch.Tensor` de forme `(batch_size, hidden_size)`) -- État caché de la dernière couche du premier jeton de la séquence (jeton de classification) après un traitement supplémentaire par les couches utilisées pour la tâche de pré-entraînement auxiliaire. Par exemple, pour les modèles de la famille BERT, cela renvoie le jeton de classification après traitement par une couche linéaire et une fonction d'activation tanh. Les poids de la couche linéaire sont entraînés à partir de l'objectif de prédiction de la phrase suivante (classification) pendant le pré-entraînement.
- **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, Qwen2_5OmniThinkerForConditionalGeneration

>>> model = Qwen2_5OmniThinkerForConditionalGeneration.from_pretrained("Qwen/Qwen2.5-Omni-7B")
>>> processor = AutoProcessor.from_pretrained("Qwen/Qwen2.5-Omni-7B")

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

#### get_image_features[[transformers.Qwen2_5OmniThinkerForConditionalGeneration.get_image_features]]

```python
get_image_features(pixel_values: Tensor, image_grid_thw: typing.Optional[torch.LongTensor] = None, **kwargs: *<class 'transformers.utils.generic.TransformersKwargs'>)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/qwen2_5_omni/modeling_qwen2_5_omni.py#L1986)

**Paramètres :**

pixel_values (`torch.Tensor` de forme `(batch_size, num_channels, image_size, image_size)`) : Les tenseurs correspondant aux images d'entrée.

image_grid_thw (`torch.LongTensor` de forme `(num_images, 3)`, *facultatif*) : La dimension temporelle, la hauteur et la largeur de la forme des caractéristiques de chaque image dans le LLM.

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

Un [BaseModelOutputWithPooling](/docs/transformers/v5.23.0/fr/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPooling) 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 ([Qwen2_5OmniConfig](/docs/transformers/v5.23.0/fr/model_doc/qwen2_5_omni#transformers.Qwen2_5OmniConfig)) et les entrées.

- **last_hidden_state** (`torch.Tensor` de forme `(batch_size, sequence_length, hidden_size)`) -- Séquence d'états cachés à la sortie de la dernière couche du modèle.
- **pooler_output** (`torch.Tensor` de forme `(batch_size, hidden_size)`) -- État caché de la dernière couche du premier jeton de la séquence (jeton de classification) après un traitement supplémentaire par les couches utilisées pour la tâche de pré-entraînement auxiliaire. Par exemple, pour les modèles de la famille BERT, cela renvoie le jeton de classification après traitement par une couche linéaire et une fonction d'activation tanh. Les poids de la couche linéaire sont entraînés à partir de l'objectif de prédiction de la phrase suivante (classification) pendant le pré-entraînement.
- **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, Qwen2_5OmniThinkerForConditionalGeneration

>>> model = Qwen2_5OmniThinkerForConditionalGeneration.from_pretrained("Qwen/Qwen2.5-Omni-7B")
>>> processor = AutoProcessor.from_pretrained("Qwen/Qwen2.5-Omni-7B")

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

#### get_video_features[[transformers.Qwen2_5OmniThinkerForConditionalGeneration.get_video_features]]

```python
get_video_features(pixel_values_videos: Tensor, video_grid_thw: typing.Optional[torch.LongTensor] = None, **kwargs: *<class 'transformers.utils.generic.TransformersKwargs'>)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/qwen2_5_omni/modeling_qwen2_5_omni.py#L1973)

**Paramètres :**

pixel_values_videos (`torch.Tensor` de forme `(batch_size, num_channels, image_size, image_size)`) : Les tenseurs correspondant aux vidéos d'entrée.

video_grid_thw (`torch.LongTensor` de forme `(num_videos, 3)`, *facultatif*) : La dimension temporelle, la hauteur et la largeur de la forme des caractéristiques de chaque vidéo dans le LLM.

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

Un [BaseModelOutputWithPooling](/docs/transformers/v5.23.0/fr/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPooling) 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 ([Qwen2_5OmniConfig](/docs/transformers/v5.23.0/fr/model_doc/qwen2_5_omni#transformers.Qwen2_5OmniConfig)) et les entrées.

- **last_hidden_state** (`torch.Tensor` de forme `(batch_size, sequence_length, hidden_size)`) -- Séquence d'états cachés à la sortie de la dernière couche du modèle.
- **pooler_output** (`torch.Tensor` de forme `(batch_size, hidden_size)`) -- État caché de la dernière couche du premier jeton de la séquence (jeton de classification) après un traitement supplémentaire par les couches utilisées pour la tâche de pré-entraînement auxiliaire. Par exemple, pour les modèles de la famille BERT, cela renvoie le jeton de classification après traitement par une couche linéaire et une fonction d'activation tanh. Les poids de la couche linéaire sont entraînés à partir de l'objectif de prédiction de la phrase suivante (classification) pendant le pré-entraînement.
- **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, Qwen2_5OmniThinkerForConditionalGeneration

>>> model = Qwen2_5OmniThinkerForConditionalGeneration.from_pretrained("Qwen/Qwen2.5-Omni-7B")
>>> processor = AutoProcessor.from_pretrained("Qwen/Qwen2.5-Omni-7B")

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

## Qwen2_5OmniThinkerTextModel[[transformers.Qwen2_5OmniThinkerTextModel]]

#### transformers.Qwen2_5OmniThinkerTextModel[[transformers.Qwen2_5OmniThinkerTextModel]]

```python
transformers.Qwen2_5OmniThinkerTextModel(config: Qwen2_5OmniTextConfig)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/qwen2_5_omni/modeling_qwen2_5_omni.py#L1548)

**Paramètres :**

config ([Qwen2_5OmniTextConfig](/docs/transformers/v5.23.0/fr/model_doc/qwen2_5_omni#transformers.Qwen2_5OmniTextConfig)) : Classe de configuration du modèle contenant tous les paramètres du modèle. L'initialisation à partir d'un fichier de configuration ne charge pas les poids associés au modèle, uniquement la configuration. Consultez la méthode [from_pretrained()](/docs/transformers/v5.23.0/fr/main_classes/model#transformers.PreTrainedModel.from_pretrained) pour charger les poids du modèle.

Le modèle de texte Qwen2 5 Omni brut, produisant des états cachés bruts sans aucune tête spécifique au sommet.

Ce modèle hérite de [PreTrainedModel](/docs/transformers/v5.23.0/fr/main_classes/model#transformers.PreTrainedModel). Consultez la documentation de la classe parente pour les méthodes génériques que la bibliothèque implémente pour tous ses modèles (tels que le téléchargement ou l'enregistrement, le redimensionnement des embeddings d'entrée, l'élagage des têtes, etc.).

Ce modèle est également une sous-classe de [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) de PyTorch. Utilisez-le comme un module PyTorch standard et consultez la documentation de PyTorch pour tout ce qui concerne l’utilisation et le comportement généraux.

#### forward[[transformers.Qwen2_5OmniThinkerTextModel.forward]]

```python
forward(input_ids: typing.Optional[torch.LongTensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, position_ids: typing.Optional[torch.LongTensor] = None, past_key_values: transformers.cache_utils.Cache | None = None, inputs_embeds: typing.Optional[torch.Tensor] = None, use_cache: bool | None = None, **kwargs: *<class 'transformers.modeling_flash_attention_utils.FlashAttentionKwargs'>)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/qwen2_5_omni/modeling_qwen2_5_omni.py#L1575)

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

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

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

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

Un [BaseModelOutputWithPast](/docs/transformers/v5.23.0/fr/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPast) 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 ([Qwen2_5OmniConfig](/docs/transformers/v5.23.0/fr/model_doc/qwen2_5_omni#transformers.Qwen2_5OmniConfig)) et les entrées.

La méthode forward du [Qwen2_5OmniThinkerTextModel](/docs/transformers/v5.23.0/fr/model_doc/qwen2_5_omni#transformers.Qwen2_5OmniThinkerTextModel) 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.

- **last_hidden_state** (`torch.Tensor` de forme `(batch_size, sequence_length, hidden_size)`) -- Séquence d'états cachés à la sortie de la dernière couche du modèle.

  Si `past_key_values` est utilisé, seule la dernière hidden-state des séquences de forme `(batch_size, 1, hidden_size)` est renvoyée.
- **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 et, le cas échéant, si `config.is_encoder_decoder=True`, dans les blocs d'attention croisée) 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.

## Qwen2_5OmniTalkerConfig[[transformers.Qwen2_5OmniTalkerConfig]]

#### transformers.Qwen2_5OmniTalkerConfig[[transformers.Qwen2_5OmniTalkerConfig]]

```python
transformers.Qwen2_5OmniTalkerConfig(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, audio_token_index: int = 151646, image_token_index: int = 151655, video_token_index: int = 151656, vocab_size: int = 8448, tts_text_start_token_id: int = 151860, tts_text_end_token_id: int = 151861, tts_text_pad_token_id: int = 151859, tts_codec_start_token_id: int = 8293, tts_codec_end_token_id: int = 8294, tts_codec_pad_token_id: int = 8292, tts_codec_mask_token_id: int = 8296, vision_start_token_id: int = 151652, vision_end_token_id: int = 151653, embedding_size: int = 3584, hidden_size: int = 3584, intermediate_size: int = 18944, num_hidden_layers: int = 28, num_attention_heads: int = 28, num_key_value_heads: int = 4, hidden_act: str = 'silu', max_position_embeddings: int = 32768, rms_norm_eps: float = 1e-06, head_dim: int = 128, use_cache: bool = True, tie_word_embeddings: bool = False, use_sliding_window: bool = False, sliding_window: int | None = 32768, max_window_layers: int = 28, attention_dropout: float | int = 0.0, rope_parameters: transformers.modeling_rope_utils.RopeParameters | dict | None = None, position_id_per_seconds: int = 25, seconds_per_chunk: int = 2, audio_start_token_id: int = 151647, audio_end_token_id: int = 151648, initializer_range: float = 0.02, spatial_merge_size: int = 2, layer_types: list[str] | None = None, pad_token_id: int | None = None)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/qwen2_5_omni/configuration_qwen2_5_omni.py#L278)

**Paramètres :**

audio_token_index (`int`, *facultatif*, valeur par défaut `151646`) : L'index du jeton audio utilisé comme espace réservé pour l'audio d'entrée.

image_token_index (`int`, *facultatif*, valeur par défaut `151655`) : L'index du jeton d'image utilisé comme espace réservé pour les images d'entrée.

video_token_index (`int`, *facultatif*, valeur par défaut `151656`) : L'index du jeton vidéo utilisé comme espace réservé pour les vidéos d'entrée.

vocab_size (`int`, *facultatif*, valeur par défaut `8448`) : Taille du vocabulaire du modèle. Définit le nombre de jetons différents qui peuvent être représentés par `input_ids`.

tts_text_start_token_id (`int`, *facultatif*, valeur par défaut 151860) : L'index du jeton de début de texte tts à encoder pour marquer le début du texte tts.

tts_text_end_token_id (`int`, *facultatif*, valeur par défaut 151861) : L'index du jeton de fin de texte tts pour encoder la fin du texte tts.

tts_text_pad_token_id (`int`, *facultatif*, valeur par défaut 151859) : L'index du jeton de remplissage du texte tts pour encoder le remplissage du texte tts.

tts_codec_start_token_id (`int`, *facultatif*, valeur par défaut 8293) : Index du jeton de début du codec tts à utiliser pour encoder le début du codec tts.

tts_codec_end_token_id (`int`, *facultatif*, valeur par défaut 8294) : L'index du jeton de fin du codec tts pour encoder la fin du codec tts.

tts_codec_pad_token_id (`int`, *facultatif*, valeur par défaut 8292) : L'index du jeton de remplissage (pad) du codec tts, utilisé pour encoder le remplissage du codec tts.

tts_codec_mask_token_id (`int`, *facultatif*, valeur par défaut 8296) : L'index du jeton de masque du codec tts à utiliser pour encoder le masque du codec tts.

vision_start_token_id (`int`, *facultatif*, valeur par défaut `151652`) : ID du jeton qui marque le début d'un segment visuel dans la séquence d'entrée multimodale.

vision_end_token_id (`int`, *facultatif*, valeur par défaut `151653`) : ID du jeton qui marque la fin d'un segment visuel dans la séquence d'entrée multimodale.

embedding_size (`int`, *facultatif*, par défaut `3584`) : Dimension des embeddings et des états cachés.

hidden_size (`int`, *facultatif*, valeur par défaut `3584`) : Dimension des représentations cachées.

intermediate_size (`int`, *facultatif*, par défaut `18944`) : Dimension des représentations MLP.

num_hidden_layers (`int`, *facultatif*, par défaut `28`) : Nombre de couches cachées dans le décodeur Transformer.

num_attention_heads (`int`, *facultatif*, valeur par défaut `28`) : Nombre de têtes d'attention pour chaque couche d'attention du décodeur Transformer.

num_key_value_heads (`int`, *facultatif*, valeur par défaut `4`) : C'est le nombre de têtes key_value à utiliser pour implémenter l'attention Grouped Query. Si `num_key_value_heads=num_attention_heads`, le modèle utilisera l'attention Multi Head (MHA) ; si `num_key_value_heads=1`, il utilisera l'attention Multi Query (MQA) ; sinon, c'est l'attention GQA qui est utilisée. Lors de la conversion d'un checkpoint multi-têtes vers un checkpoint GQA, chaque tête clé et valeur de groupe doit être construite en effectuant la moyenne (meanpooling) de toutes les têtes d'origine appartenant à ce groupe. Pour plus de détails, consultez [cet article](https://huggingface.co/papers/2305.13245). S'il n'est pas spécifié, la valeur par défaut est `num_attention_heads`.

hidden_act (`str`, *facultatif*, par défaut `silu`) : La fonction d'activation non linéaire (fonction ou chaîne de caractères) dans le décodeur. Par exemple, `"gelu"`, `"relu"`, `"silu"`, etc.

max_position_embeddings (`int`, *facultatif*, valeur par défaut `32768`) : La longueur de séquence maximale avec laquelle ce modèle pourrait être utilisé.

rms_norm_eps (`float`, *facultatif*, valeur par défaut `1e-06`) : L'épsilon utilisé par les couches de normalisation rms.

head_dim (`int`, *facultatif*, valeur par défaut `128`) : La dimension des têtes d'attention. Si None, la valeur par défaut est hidden_size // num_attention_heads

use_cache (`bool`, *facultatif*, valeur par défaut `True`) : Indique si le modèle doit retourner les dernières attentions clés/valeurs (non utilisé par tous les modèles). Pertinent uniquement si `config.is_decoder=True` ou si le modèle est un modèle génératif de type décodeur uniquement.

tie_word_embeddings (`bool`, *facultatif*, valeur par défaut `False`) : Indique s'il faut lier les embeddings de poids selon la correspondance `tied_weights_keys` du modèle.

use_sliding_window (`bool`, *facultatif*, par défaut `False`) : Indique s'il faut utiliser l'attention à fenêtre glissante.

sliding_window (`int`, *facultatif*, valeur par défaut `32768`) : Taille de la fenêtre de l'attention à fenêtre glissante. Si `None`, aucune fenêtre glissante n'est appliquée.

max_window_layers (`int`, *facultatif*, valeur par défaut `28`) : Le nombre de couches utilisant l'attention complète. Les `max_window_layers` premières couches utiliseront l'attention complète, tandis que toute couche supplémentaire qui suivra utilisera le SWA (Sliding Window Attention).

attention_dropout (`Union[float, int]`, *facultatif*, valeur par défaut `0.0`) : Le taux de dropout appliqué aux probabilités d'attention.

rope_parameters (`Union[~modeling_rope_utils.RopeParameters, dict]`, *facultatif*) : Dictionnaire contenant les paramètres de configuration pour les embeddings RoPE. Le dictionnaire doit contenir une valeur pour `rope_theta` et, le cas échéant, les paramètres utilisés pour le mise à l'échelle si vous souhaitez utiliser RoPE avec des `max_position_embeddings` plus longs.

position_id_per_seconds (`int`, *facultatif*, valeur par défaut : 25) : L'incrément de l'identifiant de position par seconde.

seconds_per_chunk (`int`, *facultatif*, valeur par défaut : 2) : La durée, en secondes, de la portion de données audio et vidéo.

audio_start_token_id (`int`, *facultatif*, valeur par défaut 151647) : L'index du jeton de début d'audio à utiliser pour encoder le prompt audio.

audio_end_token_id (`int`, *facultatif*, valeur par défaut 151648) : L'index du jeton de fin d'audio à utiliser pour encoder le prompt audio.

initializer_range (`float`, *facultatif*, valeur par défaut `0.02`) : L'écart-type de la truncated_normal_initializer utilisé pour l'initialisation de toutes les matrices de poids.

spatial_merge_size (`int`, *facultatif*, valeur par défaut `2`) : La taille de la fenêtre de fusion spatiale utilisée pour réduire le nombre de jetons visuels en fusionnant les patches voisins.

layer_types (`list[str]`, *facultatif*) : Une liste qui associe explicitement chaque index de couche à son type de couche. S'il n'est pas fourni, il sera généré automatiquement en fonction des valeurs de configuration.

pad_token_id (`int`, *facultatif*) : Identifiant de jeton utilisé pour le bourrage dans le vocabulaire.

Il s'agit de la classe de configuration destinée à stocker la configuration d'un modèle Qwen2 5 OmniModel. Elle est utilisée pour instancier un modèle Qwen2 5 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 [Qwen/Qwen2.5-Omni-7B](https://huggingface.co/Qwen/Qwen2.5-Omni-7B)

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.

Exemple :

```python
>>> from transformers import Qwen2_5OmniTalkerForConditionalGeneration, Qwen2_5OmniThinkerConfig, Qwen2_5OmniAudioEncoderConfig, Qwen2_5OmniVisionEncoderConfig

>>> # Initializing a Qwen2_5OmniAudioEncoder config
>>> audio_config = Qwen2_5OmniAudioEncoderConfig()

>>> # Initializing a Qwen2 config
>>> text_config = Qwen2Config()

>>> # Initializing a Qwen2_5Omni configuration
>>> configuration = Qwen2_5OmniThinkerConfig(audio_config, text_config)

>>> # Initializing a model from the qwen2-audio style configuration
>>> model = Qwen2_5OmniTalkerForConditionalGeneration(configuration)

>>> # Accessing the model configuration
>>> configuration = model.config
```

## Qwen2_5OmniTalkerForConditionalGeneration[[transformers.Qwen2_5OmniTalkerForConditionalGeneration]]

#### transformers.Qwen2_5OmniTalkerForConditionalGeneration[[transformers.Qwen2_5OmniTalkerForConditionalGeneration]]

```python
transformers.Qwen2_5OmniTalkerForConditionalGeneration(config: Qwen2_5OmniTalkerConfig)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/qwen2_5_omni/modeling_qwen2_5_omni.py#L2300)

#### forward[[transformers.Qwen2_5OmniTalkerForConditionalGeneration.forward]]

```python
forward(input_ids: typing.Optional[torch.LongTensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, position_ids: typing.Optional[torch.LongTensor] = None, past_key_values: transformers.cache_utils.Cache | None = None, thinker_reply_part: typing.Optional[torch.Tensor] = None, inputs_embeds: typing.Optional[torch.Tensor] = None, use_cache: bool | None = None, input_text_ids: typing.Optional[torch.LongTensor] = None, image_grid_thw: typing.Optional[torch.LongTensor] = None, video_grid_thw: typing.Optional[torch.LongTensor] = None, use_audio_in_video: bool | None = None, audio_feature_lengths: typing.Optional[torch.LongTensor] = None, video_second_per_grid: typing.Optional[torch.LongTensor] = None, **kwargs)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/qwen2_5_omni/modeling_qwen2_5_omni.py#L2334)

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

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

thinker_reply_part (`torch.Tensor` de forme `(batch_size, sequence_length, hidden_size)`, *facultatif*) : États cachés issus de la sortie du modèle thinker qui représentent la partie de la réponse textuelle à traiter.

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

input_text_ids (`torch.LongTensor` de forme `(batch_size, sequence_length)`, *facultatif*) : Identifiants de jetons d'entrée pour le contenu texte uniquement, utilisés pour le calcul des positions dans les contextes multimodaux.

image_grid_thw (`torch.LongTensor` de forme `(num_images, 3)`, *facultatif*) : La dimension temporelle, la hauteur et la largeur de la forme des caractéristiques de chaque image dans le LLM.

video_grid_thw (`torch.LongTensor` de forme `(num_videos, 3)`, *facultatif*) : La dimension temporelle, la hauteur et la largeur de la forme des caractéristiques de chaque vidéo dans le LLM.

use_audio_in_video (`bool`, *facultatif*) : Indique s'il faut utiliser la piste audio de la vidéo. Doit être identique au paramètre de `process_audio_info`.

audio_feature_lengths (`torch.LongTensor` de forme `(num_audios)`, *facultatif*) : La longueur de la forme des caractéristiques de chaque audio dans le LLM.

video_second_per_grid (`torch.LongTensor` de forme `(num_videos)`, *facultatif*) : Nombre de secondes par grille pour chaque vidéo, utilisé pour le mappage des caractéristiques temporelles.

**Retourne :** `Qwen2_5OmniTalkerCausalLMOutputWithPast` ou `tuple(torch.Tensor)`

Un `Qwen2_5OmniTalkerCausalLMOutputWithPast` 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 ([Qwen2_5OmniConfig](/docs/transformers/v5.23.0/fr/model_doc/qwen2_5_omni#transformers.Qwen2_5OmniConfig)) et les entrées.

La méthode forward de [Qwen2_5OmniTalkerForConditionalGeneration](/docs/transformers/v5.23.0/fr/model_doc/qwen2_5_omni#transformers.Qwen2_5OmniTalkerForConditionalGeneration) 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.
- **thinker_reply_part** (`torch.Tensor` de forme `(batch_size, sequence_length, hidden_size)`) -- États cachés issus du modèle thinker utilisés comme entrée pour le modèle talker. Ils représentent la réponse encodée que le modèle talker utilisera pour générer des jetons de parole.

Exemple :

```python
>>> from transformers import AutoProcessor, Qwen2_5OmniTalkerForConditionalGeneration
>>> from transformers.audio_utils import load_audio

>>> model = Qwen2_5OmniTalkerForConditionalGeneration.from_pretrained("Qwen/Qwen2-Audio-7B")
>>> processor = AutoProcessor.from_pretrained("Qwen/Qwen2-Audio-7B")

>>> prompt = "<|audio_bos|><|AUDIO|><|audio_eos|>Generate the caption in English:"
>>> url = "https://huggingface.co/datasets/hf-internal-testing/transformers-synthetic-assets/resolve/main/audio/glass_breaking.mp3"
>>> audio = load_audio(url, sampling_rate=processor.feature_extractor.sampling_rate)

>>> inputs = processor(text=prompt, audio=audio, return_tensors="pt")

>>> # Generate
>>> generate_ids = model.generate(**inputs, max_length=30)
>>> processor.batch_decode(generate_ids, skip_special_tokens=True, clean_up_tokenization_spaces=False)[0]
"Generate the caption in English: Glass is breaking."
```

## Qwen2_5OmniTalkerModel[[transformers.Qwen2_5OmniTalkerModel]]

#### transformers.Qwen2_5OmniTalkerModel[[transformers.Qwen2_5OmniTalkerModel]]

```python
transformers.Qwen2_5OmniTalkerModel(config: Qwen2_5OmniTalkerConfig)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/qwen2_5_omni/modeling_qwen2_5_omni.py#L2185)

**Paramètres :**

config ([Qwen2_5OmniTalkerConfig](/docs/transformers/v5.23.0/fr/model_doc/qwen2_5_omni#transformers.Qwen2_5OmniTalkerConfig)) : Classe de configuration du modèle contenant tous les paramètres du modèle. L'initialisation à partir d'un fichier de configuration ne charge pas les poids associés au modèle, uniquement la configuration. Consultez la méthode [from_pretrained()](/docs/transformers/v5.23.0/fr/main_classes/model#transformers.PreTrainedModel.from_pretrained) pour charger les poids du modèle.

Le modèle Qwen2 5 Omni brut, produisant des états cachés bruts sans aucune tête spécifique au sommet.

Ce modèle hérite de [PreTrainedModel](/docs/transformers/v5.23.0/fr/main_classes/model#transformers.PreTrainedModel). Consultez la documentation de la classe parente pour les méthodes génériques que la bibliothèque implémente pour tous ses modèles (tels que le téléchargement ou l'enregistrement, le redimensionnement des embeddings d'entrée, l'élagage des têtes, etc.).

Ce modèle est également une sous-classe de [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) de PyTorch. Utilisez-le comme un module PyTorch standard et consultez la documentation de PyTorch pour tout ce qui concerne l’utilisation et le comportement généraux.

#### forward[[transformers.Qwen2_5OmniTalkerModel.forward]]

```python
forward(input_ids: typing.Optional[torch.LongTensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, position_ids: typing.Optional[torch.LongTensor] = None, past_key_values: transformers.cache_utils.Cache | None = None, inputs_embeds: typing.Optional[torch.Tensor] = None, use_cache: bool | None = None, **kwargs: *<class 'transformers.modeling_flash_attention_utils.FlashAttentionKwargs'>)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/qwen2_5_omni/modeling_qwen2_5_omni.py#L2212)

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

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

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

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

Un [BaseModelOutputWithPast](/docs/transformers/v5.23.0/fr/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPast) 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 ([Qwen2_5OmniConfig](/docs/transformers/v5.23.0/fr/model_doc/qwen2_5_omni#transformers.Qwen2_5OmniConfig)) et les entrées.

La méthode forward du [Qwen2_5OmniTalkerModel](/docs/transformers/v5.23.0/fr/model_doc/qwen2_5_omni#transformers.Qwen2_5OmniTalkerModel) 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.

- **last_hidden_state** (`torch.Tensor` de forme `(batch_size, sequence_length, hidden_size)`) -- Séquence d'états cachés à la sortie de la dernière couche du modèle.

  Si `past_key_values` est utilisé, seule la dernière hidden-state des séquences de forme `(batch_size, 1, hidden_size)` est renvoyée.
- **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 et, le cas échéant, si `config.is_encoder_decoder=True`, dans les blocs d'attention croisée) 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.

## Qwen2_5OmniToken2WavConfig[[transformers.Qwen2_5OmniToken2WavConfig]]

#### transformers.Qwen2_5OmniToken2WavConfig[[transformers.Qwen2_5OmniToken2WavConfig]]

```python
transformers.Qwen2_5OmniToken2WavConfig(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, dit_config: dict | transformers.configuration_utils.PreTrainedConfig | None = None, bigvgan_config: dict | transformers.configuration_utils.PreTrainedConfig | None = None)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/qwen2_5_omni/configuration_qwen2_5_omni.py#L484)

**Paramètres :**

dit_config (`DiT_Args`, *facultatif*) : Classe de configuration du module Diffusion Transformer (DiT) chargé de générer les spectrogrammes de Mel.

bigvgan_config (`BigVGAN_Args`, *facultatif*) : Classe de configuration du module BigVGAN, chargé de convertir les spectrogrammes de mélo en formes d'onde.

Il s'agit de la classe de configuration destinée à stocker la configuration d'un modèle Qwen2 5 OmniModel. Elle est utilisée pour instancier un modèle Qwen2 5 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 [Qwen/Qwen2.5-Omni-7B](https://huggingface.co/Qwen/Qwen2.5-Omni-7B)

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.

Exemple :

```python
>>> from transformers import Qwen2_5OmniToken2WavModel, DiT_Args, BigVGAN_Args

>>> # Initialize DiT configuration
>>> dit_config = DiT_Args(
...     dim=1024,
...     depth=22,
...     heads=16,
...     ff_mult=2
... )

>>> # Initialize BigVGAN configuration
>>> bigvgan_config = BigVGAN_Args(
...     mel_dim=80,
...     upsample_rates=[5,3,2,2,2,2]
... )

>>> # Initialize main configuration
>>> config = Qwen2_5OmniToken2WavConfig(dit_config, bigvgan_config)

>>> # Initialize model with config
>>> model = Qwen2_5OmniToken2Wav(config)

>>> # Accessing the model configuration
>>> configuration = model.config
```

## Qwen2_5OmniToken2WavModel[[transformers.Qwen2_5OmniToken2WavModel]]

#### transformers.Qwen2_5OmniToken2WavModel[[transformers.Qwen2_5OmniToken2WavModel]]

```python
transformers.Qwen2_5OmniToken2WavModel(config: Qwen2_5OmniToken2WavConfig)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/qwen2_5_omni/modeling_qwen2_5_omni.py#L3644)

**Paramètres :**

config ([Qwen2_5OmniToken2WavConfig](/docs/transformers/v5.23.0/fr/model_doc/qwen2_5_omni#transformers.Qwen2_5OmniToken2WavConfig)) : Classe de configuration du modèle contenant tous les paramètres du modèle. L’initialisation à partir d’un fichier de configuration ne charge pas les poids associés au modèle, uniquement la configuration. Consultez la méthode [from_pretrained()](/docs/transformers/v5.23.0/fr/main_classes/model#transformers.PreTrainedModel.from_pretrained) pour charger les poids du modèle.

Le modèle complet Qwen2.5Omni Token2Wav. Il est composé d'un modèle DiT qui prend des jetons de parole en entrée et prédit un spectrogramme mel, ainsi que d'un vocodeur BigVGAN qui prend un spectrogramme mel en entrée et prédit le signal audio.

Ce modèle hérite de [PreTrainedModel](/docs/transformers/v5.23.0/fr/main_classes/model#transformers.PreTrainedModel). Consultez la documentation de la classe parente pour les méthodes génériques que la bibliothèque implémente pour tous ses modèles (tels que le téléchargement ou l'enregistrement, le redimensionnement des embeddings d'entrée, l'élagage des têtes, etc.).

Ce modèle est également une sous-classe de [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) de PyTorch. Utilisez-le comme un module PyTorch standard et consultez la documentation de PyTorch pour tout ce qui concerne l’utilisation et le comportement généraux.

#### forward[[transformers.Qwen2_5OmniToken2WavModel.forward]]

```python
forward(code, conditioning, reference_mel, num_steps = 10, guidance_scale = 0.5, sway_coefficient = -1.0, **kwargs)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/qwen2_5_omni/modeling_qwen2_5_omni.py#L3673)

Génère une forme d'onde à partir du code d'entrée et des paramètres de conditionnement.

## Qwen2_5OmniToken2WavDiTModel[[transformers.Qwen2_5OmniToken2WavDiTModel]]

#### transformers.Qwen2_5OmniToken2WavDiTModel[[transformers.Qwen2_5OmniToken2WavDiTModel]]

```python
transformers.Qwen2_5OmniToken2WavDiTModel(config: Qwen2_5OmniDiTConfig)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/qwen2_5_omni/modeling_qwen2_5_omni.py#L3473)

**Paramètres :**

config ([Qwen2_5OmniDiTConfig](/docs/transformers/v5.23.0/fr/model_doc/qwen2_5_omni#transformers.Qwen2_5OmniDiTConfig)) : Classe de configuration du modèle contenant tous les paramètres du modèle. L'initialisation à partir d'un fichier de configuration ne charge pas les poids associés au modèle, uniquement la configuration. Consultez la méthode [from_pretrained()](/docs/transformers/v5.23.0/fr/main_classes/model#transformers.PreTrainedModel.from_pretrained) pour charger les poids du modèle.

Le modèle complet Qwen2.5Omni Token2WavDiT. Il prend des jetons de parole en entrée et prédit le spectrogramme de mel.

Ce modèle hérite de [PreTrainedModel](/docs/transformers/v5.23.0/fr/main_classes/model#transformers.PreTrainedModel). Consultez la documentation de la classe parente pour les méthodes génériques que la bibliothèque implémente pour tous ses modèles (tels que le téléchargement ou l'enregistrement, le redimensionnement des embeddings d'entrée, l'élagage des têtes, etc.).

Ce modèle est également une sous-classe de [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) de PyTorch. Utilisez-le comme un module PyTorch standard et consultez la documentation de PyTorch pour tout ce qui concerne l’utilisation et le comportement généraux.

## Qwen2_5OmniToken2WavBigVGANModel[[transformers.Qwen2_5OmniToken2WavBigVGANModel]]

#### transformers.Qwen2_5OmniToken2WavBigVGANModel[[transformers.Qwen2_5OmniToken2WavBigVGANModel]]

```python
transformers.Qwen2_5OmniToken2WavBigVGANModel(config: Qwen2_5OmniBigVGANConfig)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/qwen2_5_omni/modeling_qwen2_5_omni.py#L3335)

**Paramètres :**

config ([Qwen2_5OmniBigVGANConfig](/docs/transformers/v5.23.0/fr/model_doc/qwen2_5_omni#transformers.Qwen2_5OmniBigVGANConfig)) : Classe de configuration du modèle contenant tous les paramètres du modèle. L'initialisation à partir d'un fichier de configuration ne charge pas les poids associés au modèle, uniquement la configuration. Consultez la méthode [from_pretrained()](/docs/transformers/v5.23.0/fr/main_classes/model#transformers.PreTrainedModel.from_pretrained) pour charger les poids du modèle.

Le modèle complet Qwen2.5Omni Token2WavBigVGAN. Il prend un spectrogramme mel en entrée et prédit le signal audio.

Ce modèle hérite de [PreTrainedModel](/docs/transformers/v5.23.0/fr/main_classes/model#transformers.PreTrainedModel). Consultez la documentation de la classe parente pour les méthodes génériques que la bibliothèque implémente pour tous ses modèles (tels que le téléchargement ou l'enregistrement, le redimensionnement des embeddings d'entrée, l'élagage des têtes, etc.).

Ce modèle est également une sous-classe de [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) de PyTorch. Utilisez-le comme un module PyTorch standard et consultez la documentation de PyTorch pour tout ce qui concerne l’utilisation et le comportement généraux.

