Hugging Face's logo

Transformers documentation

Qwen2.5-Omni

You are viewing main version, which requires installation from source. If you'd like regular pip install, checkout the latest stable version (v5.22.1).
Hugging Face's logo
Join the Hugging Face community

and get access to the augmented documentation experience

to get started

Ce modèle a été publié dans HF papers le 2025-03-26 et contribué à Hugging Face Transformers le 2025-04-14.

Qwen2.5-Omni

FlashAttention SDPA

Aperçu

Le modèle Qwen2.5-Omni est un modèle unifié multi-modalités proposé dans le Qwen2.5-Omni Technical Report 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, y compris 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 séquentiellement de manière 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éceptif, visant à réduire la latence initiale du paquet. Qwen2.5-Omni surpasse Qwen2-VL et Qwen2-Audio de taille similaire en termes de capacités image et audio. De plus, Qwen2.5-Omni atteint des performances de pointe sur des benchmarks multimodaux tels que 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é.

Définissez use_kernels=True dans from_pretrained() pour remplacer les couches prises en charge par des noyaux optimisés du Hub. Consultez Chargement des noyaux pour en savoir plus.

Notes

  • Utilisez Qwen2_5OmniForConditionalGeneration pour générer une sortie audio et texte. Pour générer un seul type de sortie, utilisez 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() pour convertir les messages de chat en entrées du modèle.

Exemple d'utilisation

Qwen2.5-Omni est disponible sur le Huggingface Hub.

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.

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.

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.

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

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.

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.

{
    "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.

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.

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.

text_ids, audio = model.generate(**inputs, speaker="Chelsie")
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 :

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

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

classe transformers.Qwen2_5OmniConfig

< >

( transformers_version: str | None = Nonearchitectures: list[str] | None = Noneoutput_hidden_states: bool | None = Falsereturn_dict: bool | None = Truedtype: str | torch.dtype | None = Nonechunk_size_feed_forward: int = 0is_encoder_decoder: bool = Falseid2label: dict[int, str] | dict[str, str] | None = Nonelabel2id: dict[str, int] | dict[str, str] | None = Noneproblem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = Nonethinker_config: dict | transformers.configuration_utils.PreTrainedConfig | None = Nonetalker_config: dict | transformers.configuration_utils.PreTrainedConfig | None = Nonetoken2wav_config: dict | transformers.configuration_utils.PreTrainedConfig | None = Noneenable_audio_output: bool = True )

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.

Ceci est 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 selon les 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

Les objets de configuration héritent de PreTrainedConfig et peuvent être utilisés pour contrôler les sorties du modèle. Consultez la documentation de PreTrainedConfig pour plus d’informations.

Exemple :

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

< >

( *args**kwargs )

Paramètres

  • decoder (Optional[bool], facultatif, 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

classe transformers.Qwen2_5OmniVisionEncoderConfig

< >

( transformers_version: str | None = Nonearchitectures: list[str] | None = Noneoutput_hidden_states: bool | None = Falsereturn_dict: bool | None = Truedtype: str | torch.dtype | None = Nonechunk_size_feed_forward: int = 0is_encoder_decoder: bool = Falseid2label: dict[int, str] | dict[str, str] | None = Nonelabel2id: dict[str, int] | dict[str, str] | None = Noneproblem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = Nonedepth: int = 32hidden_size: int = 3584hidden_act: str = 'silu'intermediate_size: int = 3420num_heads: int = 16in_channels: int = 3patch_size: int | list[int] | tuple[int, int] = 14spatial_merge_size: int = 2temporal_patch_size: int | list[int] | tuple[int, int] = 2window_size: int = 112out_hidden_size: int = 3584fullatt_block_indexes: list[int] | tuple[int, ...] = (7, 15, 23, 31)initializer_range: float = 0.02rope_parameters: dict | None = None )

Paramètres

  • depth (int, facultatif, par défaut 32) — Nombre de couches Transformer dans l'encodeur visuel.
  • hidden_size (int, facultatif, 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) du décodeur. Par exemple, "gelu", "relu", "silu", etc.
  • intermediate_size (int, facultatif, par défaut 3420) — Dimension des représentations du 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, par défaut 14) — La taille (résolution) de chaque patch.
  • spatial_merge_size (int, facultatif, 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, par défaut 2) — Taille du patch temporel utilisée dans l'intégration de patch 3D pour les entrées vidéo.
  • window_size (int, facultatif, par défaut 11) — Taille des fenêtres.
  • out_hidden_size (int, facultatif, par défaut 3584) — Taille cachée de sortie 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, par défaut 0.02) — L'écart-type de la truncated_normal_initializer utilisé pour initialiser toutes les matrices de poids.
  • rope_parameters (dict, facultatif) — Dictionnaire contenant les paramètres de configuration des 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.

Ceci est 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 selon les 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

Les objets de configuration héritent de PreTrainedConfig et peuvent être utilisés pour contrôler les sorties du modèle. Consultez la documentation de PreTrainedConfig pour plus d’informations.

Exemple :

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

classe transformers.Qwen2_5OmniTextConfig

< >

( transformers_version: str | None = Nonearchitectures: list[str] | None = Noneoutput_hidden_states: bool | None = Falsereturn_dict: bool | None = Truedtype: str | torch.dtype | None = Nonechunk_size_feed_forward: int = 0is_encoder_decoder: bool = Falseid2label: dict[int, str] | dict[str, str] | None = Nonelabel2id: dict[str, int] | dict[str, str] | None = Noneproblem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = Nonevocab_size: int = 152064hidden_size: int = 3584intermediate_size: int = 18944num_hidden_layers: int = 28num_attention_heads: int = 28num_key_value_heads: int | None = 4hidden_act: str = 'silu'max_position_embeddings: int = 32768initializer_range: float = 0.02rms_norm_eps: float = 1e-06use_cache: bool = Truerope_parameters: transformers.modeling_rope_utils.RopeParameters | dict | None = Noneuse_sliding_window: bool = Falsesliding_window: int | None = 32768max_window_layers: int = 28layer_types: list[str] | None = Noneattention_dropout: float | int = 0.0pad_token_id: int | None = Nonebos_token_id: int | None = Noneeos_token_id: int | list[int] | None = Nonetie_word_embeddings: bool = True )

Paramètres

  • vocab_size (int, facultatif, 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, par défaut 3584) — Dimension des représentations cachées.
  • intermediate_size (int, facultatif, par défaut 18944) — Dimension des représentations du 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) — Ceci 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 le modèle utilisera l'attention Multi Query (MQA), sinon l'attention GQA est utilisée. Lors de la conversion d'un checkpoint multi-têtes en checkpoint GQA, chaque tête clé et valeur de groupe doit être construite en effectuant un meanpooling de toutes les têtes d'origine au sein de ce groupe. Pour plus de détails, consultez ce papier. S'il n'est pas spécifié, la valeur par défaut sera 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) du décodeur. Par exemple, "gelu", "relu", "silu", etc.
  • max_position_embeddings (int, facultatif, par défaut 32768) — La longueur de séquence maximale avec laquelle ce modèle pourrait être utilisé.
  • initializer_range (float, facultatif, par défaut 0.02) — L'écart-type de la truncated_normal_initializer utilisé pour initialiser 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). N’est pertinent que si config.is_decoder=True ou si le modèle est un modèle génératif uniquement décodeur.
  • 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 par fenêtre glissante.
  • sliding_window (int, facultatif, par défaut 32768) — Taille de la fenêtre d'attention 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 ultérieure 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 du jeton utilisé pour le bourrage dans le vocabulaire.
  • bos_token_id (int, facultatif) — Identifiant du jeton utilisé pour le début de flux dans le vocabulaire.
  • eos_token_id (Union[int, list[int]], facultatif) — Identifiant du jeton utilisé pour la fin de flux dans le vocabulaire.
  • tie_word_embeddings (bool, facultatif, par défaut True) — Indique s'il faut lier les embeddings de poids selon la correspondance tied_weights_keys du modèle.

Ceci est 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 selon les 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

Les objets de configuration héritent de PreTrainedConfig et peuvent être utilisés pour contrôler les sorties du modèle. Consultez la documentation de PreTrainedConfig pour plus d’informations.

Exemple :

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

classe transformers.Qwen2_5OmniDiTConfig

< >

( transformers_version: str | None = Nonearchitectures: list[str] | None = Noneoutput_hidden_states: bool | None = Falsereturn_dict: bool | None = Truedtype: str | torch.dtype | None = Nonechunk_size_feed_forward: int = 0is_encoder_decoder: bool = Falseid2label: dict[int, str] | dict[str, str] | None = Nonelabel2id: dict[str, int] | dict[str, str] | None = Noneproblem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = Nonehidden_size: int = 1024num_hidden_layers: int = 22num_attention_heads: int = 16ff_mult: int = 2emb_dim: int = 512head_dim: int = 64rope_parameters: transformers.modeling_rope_utils.RopeParameters | dict | None = Nonemax_position_embeddings: int = 32768block_size: int = 24look_ahead_layers: list[int] | tuple[int, ...] = (10,)look_backward_layers: list[int] | tuple[int, ...] = (0, 20)repeats: int = 2num_embeds: int = 8193mel_dim: int = 80dropout: float | int = 0.1enc_emb_dim: int = 192enc_dim: int = 128enc_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 = 64enc_res2net_scale: int = 2enc_se_channels: int = 64 )

Paramètres

  • hidden_size (int, facultatif, 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, 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, par défaut 32768) — La longueur de séquence maximale avec laquelle ce modèle pourrait être utilisé.
  • block_size (int, facultatif, par défaut 64) — Nombre de jetons (images) dans chaque bloc de traitement.
  • look_ahead_layers (list[int], facultatif, par défaut [10]) — Nombre de couches de transformer autorisées à prêter attention aux blocs futurs
  • look_backward_layers (list[int], facultatif, par défaut [0, 20]) — Nombre de couches de transformer qui portent leur attention sur les blocs passés au-delà de la limite du bloc actuel
  • repeats (int, facultatif, valeur 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, par défaut 0.1) — Le taux appliqué à toutes les couches de dropout.
  • enc_emb_dim (int, facultatif, par défaut 192) — La dimension de l'embedding de locuteur pré-entraîné.
  • enc_dim (int, facultatif, valeur 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 de 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, valeur par défaut 64) — Le nombre de canaux de sortie après le squeeze dans le SqueezeExcitationBlock.

Ceci est 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 selon les 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

Les objets de configuration héritent de PreTrainedConfig et peuvent être utilisés pour contrôler les sorties du modèle. Consultez la documentation de PreTrainedConfig pour plus d’informations.

Qwen2_5OmniBigVGANConfig

classe transformers.Qwen2_5OmniBigVGANConfig

< >

( transformers_version: str | None = Nonearchitectures: list[str] | None = Noneoutput_hidden_states: bool | None = Falsereturn_dict: bool | None = Truedtype: str | torch.dtype | None = Nonechunk_size_feed_forward: int = 0is_encoder_decoder: bool = Falseid2label: dict[int, str] | dict[str, str] | None = Nonelabel2id: dict[str, int] | dict[str, str] | None = Noneproblem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = Nonemel_dim: int = 80upsample_initial_channel: int = 1536resblock_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) )

Paramètres

  • mel_dim (int, facultatif, valeur par défaut 80) — La dimension du spectrogramme de Mel.
  • upsample_initial_channel (int, facultatif, valeur par défaut 1536) — Le nombre de canaux de 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.

Ceci est 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 selon les 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

Les objets de configuration héritent de PreTrainedConfig et peuvent être utilisés pour contrôler les sorties du modèle. Consultez la documentation de PreTrainedConfig pour plus d’informations.

Qwen2_5OmniAudioEncoderConfig

classe transformers.Qwen2_5OmniAudioEncoderConfig

< >

( transformers_version: str | None = Nonearchitectures: list[str] | None = Noneoutput_hidden_states: bool | None = Falsereturn_dict: bool | None = Truedtype: str | torch.dtype | None = Nonechunk_size_feed_forward: int = 0is_encoder_decoder: bool = Falseid2label: dict[int, str] | dict[str, str] | None = Nonelabel2id: dict[str, int] | dict[str, str] | None = Noneproblem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = Nonenum_mel_bins: int = 128encoder_layers: int = 32encoder_attention_heads: int = 20encoder_ffn_dim: int = 5120d_model: int = 1280dropout: float | int = 0.0attention_dropout: float | int = 0.0activation_function: str = 'gelu'activation_dropout: float | int = 0.0scale_embedding: bool = Falseinitializer_range: float = 0.02max_source_positions: int = 1500n_window: int = 100output_dim: int = 3584 )

Paramètres

  • num_mel_bins (int, facultatif, 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, valeur par défaut 5120) — Dimension de la couche « intermédiaire » (souvent appelée couche feed-forward) de l’encodeur.
  • d_model (int, facultatif, par défaut 1280) — Taille des couches encodeur et de la couche pooler.
  • dropout (Union[float, int], facultatif, par défaut 0.0) — Le taux appliqué à 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) du décodeur. Par exemple, "gelu", "relu", "silu", etc.
  • activation_dropout (Union[float, int], facultatif, valeur par défaut 0.0) — Le taux de dropout appliqué aux activations à l'intérieur de la couche entièrement connectée.
  • scale_embedding (bool, facultatif, par défaut False) — Indique s'il faut mettre à l'échelle les embeddings en les divisant par sqrt(d_model).
  • initializer_range (float, facultatif, par défaut 0.02) — L'écart-type de la truncated_normal_initializer utilisé pour initialiser 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) — Le bloc utilisé pour la convolution et l'attention flash dans AudioEncoder.
  • output_dim (int, facultatif, valeur par défaut 3584) — La dimension de sortie d'AudioEncoder.

Ceci est 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 selon les 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

Les objets de configuration héritent de PreTrainedConfig et peuvent être utilisés pour contrôler les sorties du modèle. Consultez la documentation de PreTrainedConfig pour plus d’informations.

Exemple :

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

classe transformers.Qwen2_5OmniProcessor

< >

( image_processor = Nonevideo_processor = Nonefeature_extractor = Nonetokenizer = Nonechat_template = None )

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 offre toutes les fonctionnalités de Qwen2VLImageProcessor, Qwen2VLVideoProcessor, WhisperFeatureExtractor et Qwen2Tokenizer. Consultez ~Qwen2VLImageProcessor, ~Qwen2VLVideoProcessor, ~WhisperFeatureExtractor et ~Qwen2Tokenizer pour plus d’informations.

__call__

< >

( text: str | list[str] | list[list[str]] = Noneimages: typing.Union[ForwardRef('PIL.Image.Image'), numpy.ndarray, ForwardRef('torch.Tensor'), list['PIL.Image.Image'], list[numpy.ndarray], list['torch.Tensor'], NoneType] = Nonevideos: 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] = Noneaudio: 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'> ) → ~feature_extraction_utils.BatchFeature

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 de caractères (chaînes pré-tokenisées). Si vous passez 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. S'attend à une image unique ou à un lot d'images dont les valeurs de pixels vont de 0 à 255. Si vous passez 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 vont de 0 à 255. Si vous passez 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. En cas de tableau NumPy/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 spatiale des patches 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 du patch temporel utilisée par l'encodeur visuel. Cela détermine le nombre de frames consécutives regroupées en un seul patch temporel.
  • merge_size (int, kwargs, facultatif) — La taille de fusion utilisée pour combiner les patches spatiaux. Plusieurs patches sont fusionnés ensemble pour réduire la longueur de la séquence tout en conservant les informations spatiales.
  • min_frames (int, kwargs, facultatif) — Nombre minimal de frames à extraire de la vidéo. Les vidéos contenant moins de frames seront remplies 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) — 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) — 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 use_audio_in_video=True.
  • return_tensors (str ou TensorType, facultatif) — Si défini, renvoie des tenseurs d'un framework particulier. Les valeurs acceptées sont :
    • 'pt' : Renvoie des objets torch.Tensor de PyTorch.
    • 'np' : Renvoie des objets NumPy np.ndarray.
  • **kwargs (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 si tensor_type est spécifié.

Qwen2_5OmniForConditionalGeneration

classe transformers.Qwen2_5OmniForConditionalGeneration

< >

( config: Qwen2_5OmniConfig )

Paramètres

  • config (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() 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 : un transformer auto-régressif causal qui prend du texte, de l'audio, des images et des vidéos en entrée et prédit des jetons de texte.
  • Qwen2_5OmniTalkerForConditionalGeneration : un transformer auto-régressif causal qui prend en entrée les états cachés du thinker et la réponse, et prédit les jetons de parole.
  • Qwen2_5OmniToken2WavModel : un modèle DiT qui prend des jetons de parole en entrée et prédit un spectrogramme mel, ainsi qu'un vocodeur BigVGAN qui prend un spectrogramme mel en entrée et prédit un signal audio.

Ce modèle hérite de 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, la taille des têtes, etc.)

Ce modèle est également une sous-classe de 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

( *args**kwargs )

Valeur factice pour un chemin pointé (par exemple 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 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

classe transformers.Qwen2_5OmniPreTrainedModelForConditionalGeneration

< >

( config: PreTrainedConfig*inputs**kwargs )

get_chunked_index

< >

( token_indices: Tensortokens_per_chunk: intremove_index: int ) → list[tuple[int, int]]

Paramètres

  • token_indices (torch.Tensor de forme (seq_len, )) — Liste de valeurs 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 tombent 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

< >

( input_ids: typing.Optional[torch.LongTensor] = Noneimage_grid_thw: typing.Optional[torch.LongTensor] = Nonevideo_grid_thw: typing.Optional[torch.LongTensor] = Noneattention_mask: typing.Optional[torch.Tensor] = Noneuse_audio_in_video: bool = Falseaudio_seqlens: typing.Optional[torch.LongTensor] = Nonesecond_per_grids: typing.Optional[torch.Tensor] = None )

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

Calculer l'indice rope 3D en fonction de la dimension temporelle, de la hauteur et de la 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’incorporation de texte pur, l’incorporation de position rotative ne diffère pas de celle des LLM modernes. Exemples : input_ids : [T T T T T], où T désigne le texte. position_ids temporelles : [0, 1, 2, 3, 4] position_ids de hauteur : [0, 1, 2, 3, 4] position_ids de 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 image verticalement. Largeur : 2 patches, divisant chaque image horizontalement. Nous avons également certains paramètres importants : fps (Frames Per Second) : Le taux d'images par seconde de la vidéo, défini à 1. Cela signifie qu'une image est traitée chaque seconde. tokens_per_second : C'est un paramètre crucial. Il détermine le nombre d'« étapes temporelles » ou de « jetons temporels » conceptuellement regroupés dans un intervalle d'une seconde de la vidéo. Dans ce cas, nous avons 25 jetons 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 d'images qui composent un patch temporel. Ici, il s'agit de 2 images. interval : La taille de l'étape pour les identifiants 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 identifiants de position temporelle. input_ids : [V V V V V V V V V V V V T T T T T], où V est pour 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

classe transformers.Qwen2_5OmniThinkerConfig

< >

( transformers_version: str | None = Nonearchitectures: list[str] | None = Noneoutput_hidden_states: bool | None = Falsereturn_dict: bool | None = Truedtype: str | torch.dtype | None = Nonechunk_size_feed_forward: int = 0is_encoder_decoder: bool = Falseid2label: dict[int, str] | dict[str, str] | None = Nonelabel2id: dict[str, int] | dict[str, str] | None = Noneproblem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = Noneaudio_config: dict | transformers.configuration_utils.PreTrainedConfig | None = Nonevision_config: dict | transformers.configuration_utils.PreTrainedConfig | None = Nonetext_config: dict | transformers.configuration_utils.PreTrainedConfig | None = Noneaudio_token_index: int = 151646image_token_index: int = 151655video_token_index: int = 151656position_id_per_seconds: int = 25seconds_per_chunk: int = 2audio_start_token_id: int = 151647audio_end_token_id: int = 151648user_token_id: int = 872initializer_range: float = 0.02tie_word_embeddings: bool = False )

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, 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, 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, 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, du fragment de données audio et vidéo.
  • audio_start_token_id (int, facultatif, par défaut 151647) — L’index du jeton de début d’audio pour encoder le prompt audio.
  • audio_end_token_id (int, facultatif, valeur par défaut 151648) — L’indice du jeton de fin d’audio pour encoder le prompt audio.
  • user_token_id (`int, facultatif, par défaut 872) — L'index du jeton utilisateur pour encoder le jeton utilisateur.
  • initializer_range (float, facultatif, par défaut 0.02) — L'écart-type de la truncated_normal_initializer utilisé pour initialiser 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.

Ceci est 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 selon les 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

Les objets de configuration héritent de PreTrainedConfig et peuvent être utilisés pour contrôler les sorties du modèle. Consultez la documentation de PreTrainedConfig pour plus d’informations.

Exemple :

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

classe transformers.Qwen2_5OmniThinkerModel

< >

( config: Qwen2_5OmniThinkerConfig )

Paramètres

  • config (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() 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. 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, la taille des têtes, etc.)

Ce modèle est également une sous-classe de 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

< >

( input_ids: typing.Optional[torch.LongTensor] = Noneinput_features: typing.Optional[torch.FloatTensor] = Nonepixel_values: typing.Optional[torch.FloatTensor] = Nonepixel_values_videos: typing.Optional[torch.FloatTensor] = Noneimage_grid_thw: typing.Optional[torch.LongTensor] = Nonevideo_grid_thw: typing.Optional[torch.LongTensor] = Noneattention_mask: typing.Optional[torch.Tensor] = Nonefeature_attention_mask: typing.Optional[torch.Tensor] = Noneaudio_feature_lengths: typing.Optional[torch.LongTensor] = Noneposition_ids: typing.Optional[torch.LongTensor] = Nonepast_key_values: transformers.cache_utils.Cache | None = Noneinputs_embeds: typing.Optional[torch.FloatTensor] = Noneuse_cache: bool | None = Noneuse_audio_in_video: bool | None = Nonevideo_second_per_grid: typing.Optional[torch.LongTensor] = Nonemm_encoder_outputs: dict[str, transformers.modeling_outputs.BaseModelOutputWithPooling] | None = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → BaseModelOutputWithPast or tuple(torch.FloatTensor)

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. Consultez PreTrainedTokenizer.encode() et PreTrainedTokenizer.call() pour plus de détails.

    Qu'est-ce que les identifiants d'entrée ?

  • input_features (torch.FloatTensor 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. Voir WhisperFeatureExtractor.call() pour plus de détails (Qwen2_5OmniProcessor utilise WhisperFeatureExtractor pour le traitement des audios).
  • pixel_values (torch.FloatTensor 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. Voir Qwen2VLImageProcessor.call() pour plus de détails (Qwen2_5OmniProcessor utilise Qwen2VLImageProcessor pour le traitement des images).
  • pixel_values_videos (torch.FloatTensor 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 pour les vidéos peuvent être obtenues à l’aide de Qwen2VLVideoProcessor. Voir Qwen2VLVideoProcessor.call() pour plus de détails (Qwen2_5OmniProcessor utilise 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 masqués.

    Qu'est-ce que les masques d'attention ?

  • feature_attention_mask (torch.Tensor de forme (batch_size, feature_sequence_length), facultatif) — Masque pour éviter d'appliquer l'attention aux indices de fonctionnalités 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 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].

    Qu'est-ce que les identifiants de position ?

  • past_key_values (~cache_utils.Cache, facultatif) — États cachés précalculés (clés et valeurs dans les blocs d'auto-attention et d'attention croisée) qui peuvent être utilisés pour accélérer le décodage séquentiel. Cela consiste généralement en la past_key_values retournée 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 est autorisée en entrée, consultez notre guide du cache kv. Si aucun past_key_values n'est transmis, DynamicCache sera initialisé par défaut.

    Le modèle produira le même format de cache qui est 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 n’ont pas été 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.FloatTensor 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 que la matrice de recherche d’intégration interne du modèle.
  • use_cache (bool, facultatif) — Si défini sur True, les états clé-valeur 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 ou non 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 fonctions multimodales de l'encodeur fusionnées dans les embeddings de texte.

Retourne

BaseModelOutputWithPast ou tuple(torch.FloatTensor)

Un BaseModelOutputWithPast ou un tuple de torch.FloatTensor (si return_dict=False est passé ou lorsque config.return_dict=False) comprenant divers éléments en fonction de la configuration (Qwen2_5OmniConfig) et des entrées.

La méthode forward du modèle 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.FloatTensor 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. Pour plus de détails, consultez notre guide sur le cache kv.

    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.FloatTensor), facultatif, renvoyé lorsque output_hidden_states=True est passé ou lorsque config.output_hidden_states=True) — Tuple de torch.FloatTensor (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.FloatTensor), facultatif, renvoyé lorsque output_attentions=True est passé ou lorsque config.output_attentions=True) — Tuple de torch.FloatTensor (un par couche) de forme (batch_size, num_heads, sequence_length, sequence_length).

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

Qwen2_5OmniThinkerForConditionalGeneration

classe transformers.Qwen2_5OmniThinkerForConditionalGeneration

< >

( config: Qwen2_5OmniThinkerConfig )

forward

< >

( input_ids: typing.Optional[torch.LongTensor] = Noneinput_features: typing.Optional[torch.FloatTensor] = Nonepixel_values: typing.Optional[torch.FloatTensor] = Nonepixel_values_videos: typing.Optional[torch.FloatTensor] = Noneimage_grid_thw: typing.Optional[torch.LongTensor] = Nonevideo_grid_thw: typing.Optional[torch.LongTensor] = Noneattention_mask: typing.Optional[torch.Tensor] = Nonefeature_attention_mask: typing.Optional[torch.Tensor] = Noneaudio_feature_lengths: typing.Optional[torch.LongTensor] = Noneposition_ids: typing.Optional[torch.LongTensor] = Nonepast_key_values: transformers.cache_utils.Cache | None = Noneinputs_embeds: typing.Optional[torch.FloatTensor] = Nonelabels: typing.Optional[torch.LongTensor] = Noneuse_cache: bool | None = Noneuse_audio_in_video: bool | None = Nonevideo_second_per_grid: typing.Optional[torch.LongTensor] = Nonemm_encoder_outputs: dict[str, transformers.modeling_outputs.BaseModelOutputWithPooling] | None = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → CausalLMOutputWithPast or tuple(torch.FloatTensor)

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. Consultez PreTrainedTokenizer.encode() et PreTrainedTokenizer.call() pour plus de détails.

    Qu'est-ce que les identifiants d'entrée ?

  • input_features (torch.FloatTensor 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. Voir WhisperFeatureExtractor.call() pour plus de détails (Qwen2_5OmniProcessor utilise WhisperFeatureExtractor pour le traitement des audios).
  • pixel_values (torch.FloatTensor 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. Voir Qwen2VLImageProcessor.call() pour plus de détails (Qwen2_5OmniProcessor utilise Qwen2VLImageProcessor pour le traitement des images).
  • pixel_values_videos (torch.FloatTensor 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 pour les vidéos peuvent être obtenues à l’aide de Qwen2VLVideoProcessor. Voir Qwen2VLVideoProcessor.call() pour plus de détails (Qwen2_5OmniProcessor utilise 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 masqués.

    Qu'est-ce que les masques d'attention ?

  • feature_attention_mask (torch.Tensor de forme (batch_size, feature_sequence_length), facultatif) — Masque pour éviter d'appliquer l'attention aux indices de fonctionnalités 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 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].

    Qu'est-ce que les identifiants de position ?

  • past_key_values (~cache_utils.Cache, facultatif) — États cachés précalculés (clés et valeurs dans les blocs d'auto-attention et d'attention croisée) qui peuvent être utilisés pour accélérer le décodage séquentiel. Cela consiste généralement en la past_key_values retournée 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 est autorisée en entrée, consultez notre guide du cache kv. Si aucun past_key_values n'est transmis, DynamicCache sera initialisé par défaut.

    Le modèle produira le même format de cache qui est 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 n’ont pas été 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.FloatTensor 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 que 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 dans [0, ..., config.vocab_size] ou -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 dans [0, ..., config.vocab_size].
  • use_cache (bool, facultatif) — Si défini sur True, les états clé-valeur 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 ou non 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 fonctions multimodales de l'encodeur fusionnées dans les embeddings de texte.

Retourne

CausalLMOutputWithPast ou tuple(torch.FloatTensor)

Un CausalLMOutputWithPast ou un tuple de torch.FloatTensor (si return_dict=False est passé ou lorsque config.return_dict=False) comprenant divers éléments en fonction de la configuration (Qwen2_5OmniConfig) et des entrées.

La méthode forward de 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.FloatTensor de forme (1,), facultatif, renvoyé lorsque labels est fourni) — Perte de modélisation du langage (pour la prédiction du jeton suivant).

  • logits (torch.FloatTensor 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. Pour plus de détails, consultez notre guide sur le cache kv.

    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.FloatTensor), facultatif, renvoyé lorsque output_hidden_states=True est passé ou lorsque config.output_hidden_states=True) — Tuple de torch.FloatTensor (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.FloatTensor), facultatif, renvoyé lorsque output_attentions=True est passé ou lorsque config.output_attentions=True) — Tuple de torch.FloatTensor (un par couche) de forme (batch_size, num_heads, sequence_length, sequence_length).

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

Exemple :

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

< >

( input_features: FloatTensorfeature_attention_mask: typing.Optional[torch.LongTensor] = Noneaudio_feature_lengths: typing.Optional[torch.LongTensor] = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → BaseModelOutputWithPooling or tuple(torch.FloatTensor)

Paramètres

  • input_features (torch.FloatTensor) — Les tenseurs correspondant aux audios d'entrée.
  • feature_attention_mask (torch.LongTensor, facultatif) — Masque pour éviter d'appliquer l'attention aux indices de fonctionnalités de bourrage. Les valeurs du masque sont comprises 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 ou tuple(torch.FloatTensor)

Un BaseModelOutputWithPooling ou un tuple de torch.FloatTensor (si return_dict=False est passé ou lorsque config.return_dict=False) comprenant divers éléments en fonction de la configuration (Qwen2_5OmniConfig) et des entrées.

  • last_hidden_state (torch.FloatTensor 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.FloatTensor 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 à travers 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.FloatTensor), facultatif, renvoyé lorsque output_hidden_states=True est passé ou lorsque config.output_hidden_states=True) — Tuple de torch.FloatTensor (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.FloatTensor), facultatif, renvoyé lorsque output_attentions=True est passé ou lorsque config.output_attentions=True) — Tuple de torch.FloatTensor (un par couche) de forme (batch_size, num_heads, sequence_length, sequence_length).

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

Exemple :

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

< >

( pixel_values: FloatTensorimage_grid_thw: typing.Optional[torch.LongTensor] = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → BaseModelOutputWithPooling or tuple(torch.FloatTensor)

Paramètres

  • pixel_values (torch.FloatTensor 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 ou tuple(torch.FloatTensor)

Un BaseModelOutputWithPooling ou un tuple de torch.FloatTensor (si return_dict=False est passé ou lorsque config.return_dict=False) comprenant divers éléments en fonction de la configuration (Qwen2_5OmniConfig) et des entrées.

  • last_hidden_state (torch.FloatTensor 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.FloatTensor 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 à travers 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.FloatTensor), facultatif, renvoyé lorsque output_hidden_states=True est passé ou lorsque config.output_hidden_states=True) — Tuple de torch.FloatTensor (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.FloatTensor), facultatif, renvoyé lorsque output_attentions=True est passé ou lorsque config.output_attentions=True) — Tuple de torch.FloatTensor (un par couche) de forme (batch_size, num_heads, sequence_length, sequence_length).

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

Exemple :

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

< >

( pixel_values_videos: FloatTensorvideo_grid_thw: typing.Optional[torch.LongTensor] = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → BaseModelOutputWithPooling or tuple(torch.FloatTensor)

Paramètres

  • pixel_values_videos (torch.FloatTensor 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 ou tuple(torch.FloatTensor)

Un BaseModelOutputWithPooling ou un tuple de torch.FloatTensor (si return_dict=False est passé ou lorsque config.return_dict=False) comprenant divers éléments en fonction de la configuration (Qwen2_5OmniConfig) et des entrées.

  • last_hidden_state (torch.FloatTensor 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.FloatTensor 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 à travers 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.FloatTensor), facultatif, renvoyé lorsque output_hidden_states=True est passé ou lorsque config.output_hidden_states=True) — Tuple de torch.FloatTensor (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.FloatTensor), facultatif, renvoyé lorsque output_attentions=True est passé ou lorsque config.output_attentions=True) — Tuple de torch.FloatTensor (un par couche) de forme (batch_size, num_heads, sequence_length, sequence_length).

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

Exemple :

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

classe transformers.Qwen2_5OmniThinkerTextModel

< >

( config: Qwen2_5OmniTextConfig )

Paramètres

  • config (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() 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. 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, la taille des têtes, etc.)

Ce modèle est également une sous-classe de 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

< >

( input_ids: typing.Optional[torch.LongTensor] = Noneattention_mask: typing.Optional[torch.Tensor] = Noneposition_ids: typing.Optional[torch.LongTensor] = Nonepast_key_values: transformers.cache_utils.Cache | None = Noneinputs_embeds: typing.Optional[torch.FloatTensor] = Noneuse_cache: bool | None = None**kwargs: *<class 'transformers.modeling_flash_attention_utils.FlashAttentionKwargs'> ) → BaseModelOutputWithPast or tuple(torch.FloatTensor)

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. Consultez PreTrainedTokenizer.encode() et PreTrainedTokenizer.call() pour plus de détails.

    Qu'est-ce que les identifiants d'entrée ?

  • 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 masqués.

    Qu'est-ce que les masques d'attention ?

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

    Qu'est-ce que les identifiants de position ?

  • past_key_values (~cache_utils.Cache, facultatif) — États cachés précalculés (clés et valeurs dans les blocs d'auto-attention et d'attention croisée) qui peuvent être utilisés pour accélérer le décodage séquentiel. Cela consiste généralement en la past_key_values retournée 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 est autorisée en entrée, consultez notre guide du cache kv. Si aucun past_key_values n'est transmis, DynamicCache sera initialisé par défaut.

    Le modèle produira le même format de cache qui est 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 n’ont pas été 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.FloatTensor 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 que la matrice de recherche d’intégration interne du modèle.
  • use_cache (bool, facultatif) — Si défini sur True, les états clé-valeur past_key_values sont renvoyés et peuvent être utilisés pour accélérer le décodage (voir past_key_values).

Retourne

BaseModelOutputWithPast ou tuple(torch.FloatTensor)

Un BaseModelOutputWithPast ou un tuple de torch.FloatTensor (si return_dict=False est passé ou lorsque config.return_dict=False) comprenant divers éléments en fonction de la configuration (Qwen2_5OmniConfig) et des entrées.

La méthode forward du 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.FloatTensor 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. Pour plus de détails, consultez notre guide sur le cache kv.

    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.FloatTensor), facultatif, renvoyé lorsque output_hidden_states=True est passé ou lorsque config.output_hidden_states=True) — Tuple de torch.FloatTensor (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.FloatTensor), facultatif, renvoyé lorsque output_attentions=True est passé ou lorsque config.output_attentions=True) — Tuple de torch.FloatTensor (un par couche) de forme (batch_size, num_heads, sequence_length, sequence_length).

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

Qwen2_5OmniTalkerConfig

classe transformers.Qwen2_5OmniTalkerConfig

< >

( transformers_version: str | None = Nonearchitectures: list[str] | None = Noneoutput_hidden_states: bool | None = Falsereturn_dict: bool | None = Truedtype: str | torch.dtype | None = Nonechunk_size_feed_forward: int = 0is_encoder_decoder: bool = Falseid2label: dict[int, str] | dict[str, str] | None = Nonelabel2id: dict[str, int] | dict[str, str] | None = Noneproblem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = Noneaudio_token_index: int = 151646image_token_index: int = 151655video_token_index: int = 151656vocab_size: int = 8448tts_text_start_token_id: int = 151860tts_text_end_token_id: int = 151861tts_text_pad_token_id: int = 151859tts_codec_start_token_id: int = 8293tts_codec_end_token_id: int = 8294tts_codec_pad_token_id: int = 8292tts_codec_mask_token_id: int = 8296vision_start_token_id: int = 151652vision_end_token_id: int = 151653embedding_size: int = 3584hidden_size: int = 3584intermediate_size: int = 18944num_hidden_layers: int = 28num_attention_heads: int = 28num_key_value_heads: int = 4hidden_act: str = 'silu'max_position_embeddings: int = 32768rms_norm_eps: float = 1e-06head_dim: int = 128use_cache: bool = Truetie_word_embeddings: bool = Falseuse_sliding_window: bool = Falsesliding_window: int | None = 32768max_window_layers: int = 28attention_dropout: float | int = 0.0rope_parameters: transformers.modeling_rope_utils.RopeParameters | dict | None = Noneposition_id_per_seconds: int = 25seconds_per_chunk: int = 2audio_start_token_id: int = 151647audio_end_token_id: int = 151648initializer_range: float = 0.02spatial_merge_size: int = 2layer_types: list[str] | None = Nonepad_token_id: int | None = None )

Paramètres

  • audio_token_index (int, facultatif, 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, 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, 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, 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 pour encoder 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) — L’index du jeton de début du codec tts 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 du codec tts 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, par défaut 151652) — Identifiant 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) — Identifiant 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, par défaut 3584) — Dimension des représentations cachées.
  • intermediate_size (int, facultatif, par défaut 18944) — Dimension des représentations du 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) — Ceci 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 le modèle utilisera l'attention Multi Query (MQA), sinon l'attention GQA est utilisée. Lors de la conversion d'un checkpoint multi-têtes en checkpoint GQA, chaque tête clé et valeur de groupe doit être construite en effectuant un meanpooling de toutes les têtes d'origine au sein de ce groupe. Pour plus de détails, consultez ce papier. S'il n'est pas spécifié, la valeur par défaut sera 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) du décodeur. Par exemple, "gelu", "relu", "silu", etc.
  • max_position_embeddings (int, facultatif, 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, par défaut 128) — La dimension des têtes d'attention. Si None, elle est par défaut égale à 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). N’est pertinent que si config.is_decoder=True ou si le modèle est un modèle génératif uniquement décodeur.
  • 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 par fenêtre glissante.
  • sliding_window (int, facultatif, par défaut 32768) — Taille de la fenêtre d'attention 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 ultérieure 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, du fragment de données audio et vidéo.
  • audio_start_token_id (int, facultatif, par défaut 151647) — L’index du jeton de début d’audio pour encoder le prompt audio.
  • audio_end_token_id (int, facultatif, valeur par défaut 151648) — L’indice du jeton de fin d’audio pour encoder le prompt audio.
  • initializer_range (float, facultatif, par défaut 0.02) — L'écart-type de la truncated_normal_initializer utilisé pour initialiser toutes les matrices de poids.
  • spatial_merge_size (int, facultatif, 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 du jeton utilisé pour le bourrage dans le vocabulaire.

Ceci est 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 selon les 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

Les objets de configuration héritent de PreTrainedConfig et peuvent être utilisés pour contrôler les sorties du modèle. Consultez la documentation de PreTrainedConfig pour plus d’informations.

Exemple :

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

classe transformers.Qwen2_5OmniTalkerForConditionalGeneration

< >

( config: Qwen2_5OmniTalkerConfig )

forward

< >

( input_ids: typing.Optional[torch.LongTensor] = Noneattention_mask: typing.Optional[torch.Tensor] = Noneposition_ids: typing.Optional[torch.LongTensor] = Nonepast_key_values: transformers.cache_utils.Cache | None = Nonethinker_reply_part: typing.Optional[torch.FloatTensor] = Noneinputs_embeds: typing.Optional[torch.FloatTensor] = Noneuse_cache: bool | None = Noneinput_text_ids: typing.Optional[torch.LongTensor] = Noneimage_grid_thw: typing.Optional[torch.LongTensor] = Nonevideo_grid_thw: typing.Optional[torch.LongTensor] = Noneuse_audio_in_video: bool | None = Noneaudio_feature_lengths: typing.Optional[torch.LongTensor] = Nonevideo_second_per_grid: typing.Optional[torch.LongTensor] = None**kwargs ) → Qwen2_5OmniTalkerCausalLMOutputWithPast or tuple(torch.FloatTensor)

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. Consultez PreTrainedTokenizer.encode() et PreTrainedTokenizer.call() pour plus de détails.

    Qu'est-ce que les identifiants d'entrée ?

  • 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 masqués.

    Qu'est-ce que les masques d'attention ?

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

    Qu'est-ce que les identifiants de position ?

  • past_key_values (~cache_utils.Cache, facultatif) — États cachés précalculés (clés et valeurs dans les blocs d'auto-attention et d'attention croisée) qui peuvent être utilisés pour accélérer le décodage séquentiel. Cela consiste généralement en la past_key_values retournée 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 est autorisée en entrée, consultez notre guide du cache kv. Si aucun past_key_values n'est transmis, DynamicCache sera initialisé par défaut.

    Le modèle produira le même format de cache qui est 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 n’ont pas été 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.FloatTensor 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.FloatTensor 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 que la matrice de recherche d’intégration interne du modèle.
  • use_cache (bool, facultatif) — Si défini sur True, les états clé-valeur 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 des 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 ou non 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.FloatTensor)

Un Qwen2_5OmniTalkerCausalLMOutputWithPast ou un tuple de torch.FloatTensor (si return_dict=False est passé ou lorsque config.return_dict=False) comprenant divers éléments en fonction de la configuration (Qwen2_5OmniConfig) et des entrées.

La méthode forward de 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.FloatTensor de forme (1,), facultatif, renvoyé lorsque labels est fourni) — Perte de modélisation du langage (pour la prédiction du jeton suivant).

  • logits (torch.FloatTensor 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. Pour plus de détails, consultez notre guide sur le cache kv.

    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.FloatTensor), facultatif, renvoyé lorsque output_hidden_states=True est passé ou lorsque config.output_hidden_states=True) — Tuple de torch.FloatTensor (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.FloatTensor), facultatif, renvoyé lorsque output_attentions=True est passé ou lorsque config.output_attentions=True) — Tuple de torch.FloatTensor (un par couche) de forme (batch_size, num_heads, sequence_length, sequence_length).

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

  • thinker_reply_part (torch.FloatTensor 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 :

>>> from io import BytesIO
>>> from urllib.request import urlopen
>>> import librosa
>>> from transformers import AutoProcessor, Qwen2_5OmniTalkerForConditionalGeneration

>>> 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, _ = librosa.load(BytesIO(urlopen(url).read()), sr=self.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

classe transformers.Qwen2_5OmniTalkerModel

< >

( config: Qwen2_5OmniTalkerConfig )

Paramètres

  • config (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() 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. 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, la taille des têtes, etc.)

Ce modèle est également une sous-classe de 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

< >

( input_ids: typing.Optional[torch.LongTensor] = Noneattention_mask: typing.Optional[torch.Tensor] = Noneposition_ids: typing.Optional[torch.LongTensor] = Nonepast_key_values: transformers.cache_utils.Cache | None = Noneinputs_embeds: typing.Optional[torch.FloatTensor] = Noneuse_cache: bool | None = None**kwargs: *<class 'transformers.modeling_flash_attention_utils.FlashAttentionKwargs'> ) → BaseModelOutputWithPast or tuple(torch.FloatTensor)

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. Consultez PreTrainedTokenizer.encode() et PreTrainedTokenizer.call() pour plus de détails.

    Qu'est-ce que les identifiants d'entrée ?

  • 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 masqués.

    Qu'est-ce que les masques d'attention ?

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

    Qu'est-ce que les identifiants de position ?

  • past_key_values (~cache_utils.Cache, facultatif) — États cachés précalculés (clés et valeurs dans les blocs d'auto-attention et d'attention croisée) qui peuvent être utilisés pour accélérer le décodage séquentiel. Cela consiste généralement en la past_key_values retournée 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 est autorisée en entrée, consultez notre guide du cache kv. Si aucun past_key_values n'est transmis, DynamicCache sera initialisé par défaut.

    Le modèle produira le même format de cache qui est 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 n’ont pas été 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.FloatTensor 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 que la matrice de recherche d’intégration interne du modèle.
  • use_cache (bool, facultatif) — Si défini sur True, les états clé-valeur past_key_values sont renvoyés et peuvent être utilisés pour accélérer le décodage (voir past_key_values).

Retourne

BaseModelOutputWithPast ou tuple(torch.FloatTensor)

Un BaseModelOutputWithPast ou un tuple de torch.FloatTensor (si return_dict=False est passé ou lorsque config.return_dict=False) comprenant divers éléments en fonction de la configuration (Qwen2_5OmniConfig) et des entrées.

La méthode forward du 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.FloatTensor 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. Pour plus de détails, consultez notre guide sur le cache kv.

    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.FloatTensor), facultatif, renvoyé lorsque output_hidden_states=True est passé ou lorsque config.output_hidden_states=True) — Tuple de torch.FloatTensor (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.FloatTensor), facultatif, renvoyé lorsque output_attentions=True est passé ou lorsque config.output_attentions=True) — Tuple de torch.FloatTensor (un par couche) de forme (batch_size, num_heads, sequence_length, sequence_length).

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

Qwen2_5OmniToken2WavConfig

classe transformers.Qwen2_5OmniToken2WavConfig

< >

( transformers_version: str | None = Nonearchitectures: list[str] | None = Noneoutput_hidden_states: bool | None = Falsereturn_dict: bool | None = Truedtype: str | torch.dtype | None = Nonechunk_size_feed_forward: int = 0is_encoder_decoder: bool = Falseid2label: dict[int, str] | dict[str, str] | None = Nonelabel2id: dict[str, int] | dict[str, str] | None = Noneproblem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = Nonedit_config: dict | transformers.configuration_utils.PreTrainedConfig | None = Nonebigvgan_config: dict | transformers.configuration_utils.PreTrainedConfig | None = None )

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.

Ceci est 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 selon les 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

Les objets de configuration héritent de PreTrainedConfig et peuvent être utilisés pour contrôler les sorties du modèle. Consultez la documentation de PreTrainedConfig pour plus d’informations.

Exemple :

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

classe transformers.Qwen2_5OmniToken2WavModel

< >

( config: Qwen2_5OmniToken2WavConfig )

Paramètres

  • config (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() 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. 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, la taille des têtes, etc.)

Ce modèle est également une sous-classe de 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

< >

( codeconditioningreference_melnum_steps = 10guidance_scale = 0.5sway_coefficient = -1.0**kwargs )

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

Qwen2_5OmniToken2WavDiTModel

classe transformers.Qwen2_5OmniToken2WavDiTModel

< >

( config: Qwen2_5OmniDiTConfig )

Paramètres

  • config (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() 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. 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, la taille des têtes, etc.)

Ce modèle est également une sous-classe de 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

classe transformers.Qwen2_5OmniToken2WavBigVGANModel

< >

( config: Qwen2_5OmniBigVGANConfig )

Paramètres

  • config (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() 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. 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, la taille des têtes, etc.)

Ce modèle est également une sous-classe de 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.

Update on GitHub

←QianfanOCR Qwen2.5-VL→