Transformers documentation

Audio Flamingo 3

Transformers

You are viewing main version, which requires installation from source. If you'd like regular pip install, checkout the latest stable version (v5.22.2).

Join the Hugging Face community

and get access to the augmented documentation experience

Collaborate on models, datasets and Spaces

Faster examples with accelerated inference

Switch between documentation themes

to get started

Ce modèle a été publié dans HF papers le 2025-07-10 et ajouté à Hugging Face Transformers le 2025-11-12.

Audio Flamingo 3

Aperçu

Audio Flamingo 3 (AF3) est un grand modèle audio-langage entièrement ouvert, conçu pour une compréhension et un raisonnement robustes sur la parole, les sons environnementaux et la musique. AF3 associe un encodeur audio de type Whisper à un modèle de langage causal et effectue une fusion audio-texte par substitution sur place : le processeur aligne les trames audio post-pooling sur un jeton de substitution dédié, et le modèle remplace ces emplacements de jetons par des plongements audio projetés lors du passage avant.

Le point de contrôle du modèle est disponible à l'adresse : nvidia/audio-flamingo-3-hf

Points forts :

Encodeur audio unifié pour la parole, les sons et la musique.
Prise en charge des longs audios par fenêtrage et alignement post-pooling (jusqu'à 10 minutes maximum). Le modèle traite l'audio par fenêtres de 30 secondes avec une limite stricte de 20 fenêtres (10 minutes au total). Tout audio d'une durée supérieure à 10 minutes sera tronqué.
Fusion déterministe qui préserve la longueur de la séquence en remplaçant les jetons de placeholder audio par des embeddings audio.

Ce modèle a été contribué par Lasha Koroshinadze et Eric Bezzam.

Article

Audio Flamingo 3 : Améliorer l'intelligence audio avec de grands modèles audio-linguistiques entièrement ouverts
A. Goel, S. Ghosh, J. Kim, S. Kumar, Z. Kong, S. Lee, C.-H. H. Yang, R. Duraiswami, D. Manocha, R. Valle, B. Catanzaro
NVIDIA et University of Maryland
Projet : https://research.nvidia.com/labs/adlr/AF3/

Utilisation

Mode Instruct Audio

Le modèle prend en charge les instructions audio-texte, y compris les interactions multi-tours, le tout traité par lots.

➡️ audio + instruction text

from transformers import AudioFlamingo3ForConditionalGeneration, AutoProcessor


model_id = "nvidia/audio-flamingo-3-hf"
processor = AutoProcessor.from_pretrained(model_id)
model = AudioFlamingo3ForConditionalGeneration.from_pretrained(model_id, device_map="auto")

conversation = [
    {
        "role": "user",
        "content": [
            {"type": "text", "text": "Transcribe the input speech."},
            {"type": "audio", "path": "https://huggingface.co/datasets/nvidia/AudioSkills/resolve/main/assets/WhDJDIviAOg_120_10.mp3"},
        ],
    }
]

inputs = processor.apply_chat_template(
    conversation,
    tokenize=True,
    add_generation_prompt=True,
    return_dict=True,
).to(model.device, dtype=model.dtype)

outputs = model.generate(**inputs, max_new_tokens=500)

decoded_outputs = processor.decode(outputs[:, inputs.input_ids.shape[1]:], skip_special_tokens=True)
print(decoded_outputs)

➡️ multi-tours :

from transformers import AudioFlamingo3ForConditionalGeneration, AutoProcessor


model_id = "nvidia/audio-flamingo-3-hf"
processor = AutoProcessor.from_pretrained(model_id)
model = AudioFlamingo3ForConditionalGeneration.from_pretrained(model_id, device_map="auto")

conversation = [
    {
        "role": "user",
        "content": [
            {
                "type": "text",
                "text": "Instruction: How does the tone of female speech change throughout the audio? Choose the correct option among the options below: (A) Sad to happy (B) Happy to sad (C) Neutral to happy (D) Happy to neutral.",
            },
            {"type": "audio", "path": "https://huggingface.co/datasets/nvidia/AudioSkills/resolve/main/assets/000000786159.31.wav"},
        ],
    },
    {
        "role": "assistant",
        "content": [{"type": "text", "text": "(A) Sad to happy"}],
    },
    {
        "role": "user",
        "content": [
            {"type": "text", "text": "Why do you think so?"},
        ],
    },
]

inputs = processor.apply_chat_template(
    conversation,
    tokenize=True,
    add_generation_prompt=True,
    return_dict=True,
).to(model.device, dtype=model.dtype)

outputs = model.generate(**inputs, max_new_tokens=500)

decoded_outputs = processor.decode(outputs[:, inputs.input_ids.shape[1]:], skip_special_tokens=True)
print(decoded_outputs)

➡️ texte uniquement :

from transformers import AudioFlamingo3ForConditionalGeneration, AutoProcessor


model_id = "nvidia/audio-flamingo-3-hf"
processor = AutoProcessor.from_pretrained(model_id)
model = AudioFlamingo3ForConditionalGeneration.from_pretrained(model_id, device_map="auto")

conversation = [
    {
        "role": "user",
        "content": [
            {"type": "text", "text": "What is the capital of France?"},
        ],
    }
]

inputs = processor.apply_chat_template(
    conversation,
    tokenize=True,
    add_generation_prompt=True,
    return_dict=True,
).to(model.device, dtype=model.dtype)

outputs = model.generate(**inputs, max_new_tokens=500)

decoded_outputs = processor.decode(outputs[:, inputs.input_ids.shape[1]:], skip_special_tokens=True)
print(decoded_outputs)

➡️ audio uniquement :

from transformers import AudioFlamingo3ForConditionalGeneration, AutoProcessor


model_id = "nvidia/audio-flamingo-3-hf"
processor = AutoProcessor.from_pretrained(model_id)
model = AudioFlamingo3ForConditionalGeneration.from_pretrained(model_id, device_map="auto")

conversation = [
    {
        "role": "user",
        "content": [
            {"type": "audio", "path": "https://huggingface.co/datasets/nvidia/AudioSkills/resolve/main/assets/WhDJDIviAOg_120_10.mp3"},
        ],
    }
]

inputs = processor.apply_chat_template(
    conversation,
    tokenize=True,
    add_generation_prompt=True,
    return_dict=True,
).to(model.device, dtype=model.dtype)

outputs = model.generate(**inputs, max_new_tokens=500)

decoded_outputs = processor.decode(outputs[:, inputs.input_ids.shape[1]:], skip_special_tokens=True)
print(decoded_outputs)

➡️ inférence par lots !

from transformers import AudioFlamingo3ForConditionalGeneration, AutoProcessor


model_id = "nvidia/audio-flamingo-3-hf"
processor = AutoProcessor.from_pretrained(model_id)
model = AudioFlamingo3ForConditionalGeneration.from_pretrained(model_id, device_map="auto")

conversations = [
    [
        {
            "role": "user",
            "content": [
                {"type": "text", "text": "Transcribe the input speech."},
                {
                    "type": "audio",
                    "path": "https://huggingface.co/datasets/nvidia/AudioSkills/resolve/main/assets/t_837b89f2-26aa-4ee2-bdf6-f73f0dd59b26.wav",
                },
            ],
        }
    ],
    [
        {
            "role": "user",
            "content": [
                {
                    "type": "text",
                    "text": "This track feels really peaceful and introspective. What elements make it feel so calming and meditative?",
                },
                {"type": "audio", "path": "https://huggingface.co/datasets/nvidia/AudioSkills/resolve/main/assets/FPSbCAANfbJLVSwD.mp3"},
            ],
        }
    ],
]

inputs = processor.apply_chat_template(
    conversations,
    tokenize=True,
    add_generation_prompt=True,
    return_dict=True,
).to(model.device, dtype=model.dtype)

outputs = model.generate(**inputs, max_new_tokens=500)

decoded_outputs = processor.decode(outputs[:, inputs.input_ids.shape[1]:], skip_special_tokens=True)
print(decoded_outputs)

➡️ Entraînement :

transcription

chat template

➡️ raccourci de transcription

from transformers import AudioFlamingo3ForConditionalGeneration, AutoProcessor


model_id = "nvidia/audio-flamingo-3-hf"
processor = AutoProcessor.from_pretrained(model_id)
model = AudioFlamingo3ForConditionalGeneration.from_pretrained(model_id, device_map="auto")

inputs = processor.apply_transcription_request(audio="https://huggingface.co/datasets/nvidia/AudioSkills/resolve/main/assets/t_837b89f2-26aa-4ee2-bdf6-f73f0dd59b26.wav").to(model.device, dtype=model.dtype)

outputs = model.generate(**inputs, max_new_tokens=500)
decoded_outputs = processor.decode(outputs[:, inputs.input_ids.shape[1]:], skip_special_tokens=True, strip_prefix=True)

print(decoded_outputs)

Le modèle est entraîné à émettre des transcriptions préfixées par un encadrement d’assistant tel que The spoken content of the audio is "<text>".. Utilisez strip_prefix=True (comme indiqué ci-dessus) pour supprimer la phrase fixe de l’assistant et les guillemets environnants afin qu’il ne reste que la transcription.

Fonctionnement du modèle

Architecture

AudioFlamingo3Encoder Extracteur de caractéristiques et encodeur de type Whisper → moyenne sur le temps (pas 2) → LayerNorm. Produit des états cachés par image à la fréquence post-pooling.
AudioFlamingo3MultiModalProjector Un petit MLP qui mappe les caractéristiques de l’encodeur vers la taille cachée du modèle de langage.
AudioFlamingo3ForConditionalGeneration Un modèle de langage causal qui accepte des embeddings de texte où chaque emplacement de jeton de remplacement audio est remplacé, sur place, par un embedding de trame audio. La fusion n’entraîne aucun changement de longueur de séquence.

Alignement au niveau du processeur

Chaque forme d’onde brute est découpée en fenêtres de longueur fixe en fonction de chunk_length (secondes) et de sampling_rate (Hz) de l’extracteur de caractéristiques.
Pour chaque fenêtre, le processeur calcule le nombre de trames post-pooling post_pool_len que le encodeur produira (correspondant à l'agenda conv/pool).
Le processeur étend le jeton de placeholder audio par le nombre total de trames post-pooling sur toutes les fenêtres.
Le modèle remplace ensuite ces positions de jetons par les embeddings audio projetés correspondants.

Modèles d'utilisation

Raccourci de transcription

Pour la reconnaissance vocale automatique, vous pouvez éviter d’écrire l’instruction par défaut à chaque fois et appeler apply_transcription_request() :

inputs = processor.apply_transcription_request(audio=audio_array)

Passez prompt="Transcribe the input speech." (ou une liste de prompts pour un lot d’audio) pour personnaliser l’instruction tout en conservant la gestion du placeholder audio.

audio accepte des tableaux en mémoire, des chemins de fichiers locaux ou des URL. Tous les arguments du processeur (text_kwargs, audio_kwargs, etc.) sont transmis, ce qui permet d’ajuster le bourrage ou les formats de tenseurs comme lors de l’appel de processor(...).

Audio long et fenêtrage

Important : la durée maximale de l'audio est de 10 minutes. Tout audio plus long sera tronqué.

La configuration par défaut traite des fenêtres de 30 secondes en mono à 16 kHz.
Le processeur impose une limite stricte de 20 fenêtres par échantillon, ce qui correspond à un maximum de 10 minutes d'audio (20 fenêtres × 30 secondes).
Pour chaque fenêtre :
- mel_len est la longueur mel rembourrée.
- Une pile de convolutions réduit le temps, car conv_output_len = (mel_len - 1) // 2 + 1.
- Images par fenêtre après pooling : post_pool_len = (conv_output_len - 2) // 2 + 1.
- Un jeton de réserve audio est développé en la somme de post_pool_len sur toutes les fenêtres.

Remplissage, attention et mise en cache

Rembourrage à gauche vs rembourrage à droite Pour la génération avec des longueurs de prompt mixtes dans un lot, le rembourrage à gauche est généralement préférable. Pour l’entraînement, le rembourrage à droite est courant ; le mécanisme de fusion d’AF3 est lui-même indépendant du rembourrage, car il remplace sur place.
Masques d'attention Le processeur renvoie attention_mask (texte) et input_features_mask (audio). Le modèle construit un masque interne 4-D sur l'axe pré-pooling de l'encodeur, avec des valeurs négatives infinies aux positions de bourrage.
Mise en cache Lors de la génération, input_features et input_features_mask ne sont transmis qu'à la première étape. Les étapes suivantes utilisent les clés/valeurs mises en cache par le modèle de langage.

Dépannage

Sorties vides ou tronquées lors du batch Utilisez le padding à gauche pour la génération par batch et décodez uniquement les nouveaux jetons après la longueur du prompt, comme indiqué dans le démarrage rapide.

AudioFlamingo3Config

classe transformers.AudioFlamingo3Config

< source >

( 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 = Nonetext_config: dict | transformers.configuration_utils.PreTrainedConfig | None = Noneaudio_token_id: int = 151669projector_hidden_act: str = 'gelu'projector_bias: bool = True )

Paramètres

audio_config (Union[dict, ~configuration_utils.PreTrainedConfig], facultatif) — L'objet de configuration ou le dictionnaire du backbone audio.
text_config (Union[dict, ~configuration_utils.PreTrainedConfig], facultatif) — L'objet de configuration ou le dictionnaire du backbone de texte.
audio_token_id (int, facultatif, par défaut 151669) — L’index du jeton audio utilisé comme espace réservé pour l’audio d’entrée.
projector_hidden_act (str, facultatif, par défaut gelu) — La fonction d'activation utilisée par le projecteur multimodal.
projector_bias (bool, facultatif, valeur par défaut True) — Indique s'il faut utiliser un biais dans le projecteur multimodal.

Ceci est la classe de configuration destinée à stocker la configuration d'un AudioFlamingo3Model. Elle est utilisée pour instancier un modèle Audioflamingo3 en fonction des arguments spécifiés, définissant ainsi l'architecture du modèle. L'instanciation d'une configuration avec les valeurs par défaut produira une configuration similaire à celle de nvidia/audio-flamingo-3-hf

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 AudioFlamingo3ForConditionalGeneration, AudioFlamingo3Config, AudioFlamingo3EncoderConfig, Qwen2Config

>>> # Initializing an AudioFlamingo3Encoder config
>>> audio_config = AudioFlamingo3EncoderConfig()

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

>>> # Initializing an AudioFlamingo3 configuration
>>> configuration = AudioFlamingo3Config(audio_config, text_config)

>>> # Initializing a model from the audioflamingo3 style configuration
>>> model = AudioFlamingo3ForConditionalGeneration(configuration)

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

AudioFlamingo3EncoderConfig

classe transformers.AudioFlamingo3EncoderConfig

< source >

( 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 = 128num_hidden_layers: int = 32num_attention_heads: int = 20intermediate_size: int = 5120layerdrop: float | int = 0.0activation_function: str = 'gelu'hidden_size: int = 1280dropout: float | int = 0.0attention_dropout: float | int = 0.0activation_dropout: float | int = 0.0initializer_range: float = 0.02scale_embedding: bool = Falsemax_source_positions: int = 1500 )

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.
num_hidden_layers (int, facultatif, par défaut 32) — Nombre de couches cachées dans le décodeur Transformer.
num_attention_heads (int, facultatif, valeur par défaut 20) — Nombre de têtes d'attention pour chaque couche d'attention du décodeur Transformer.
intermediate_size (int, facultatif, par défaut 5120) — Dimension des représentations du MLP.
layerdrop (Union[float, int], facultatif, par défaut 0.0) — La probabilité de LayerDrop. Consultez l'article [LayerDrop](voir https://huggingface.co/papers/1909.11556) pour plus de détails.
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.
hidden_size (int, facultatif, par défaut 1280) — Dimension des représentations cachées.
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_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.
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.
scale_embedding (bool, facultatif, par défaut False) — Indique s'il faut mettre à l'échelle les embeddings en les divisant par sqrt(d_model).
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é.

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 AudioFlamingo3EncoderConfig, AudioFlamingo3Encoder

>>> # Initializing an AudioFlamingo3EncoderConfig
>>> configuration = AudioFlamingo3EncoderConfig()

>>> # Initializing an AudioFlamingo3Encoder (with random weights)
>>> model = AudioFlamingo3Encoder(configuration)

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

AudioFlamingo3Processor

classe transformers.AudioFlamingo3Processor

< source >

( feature_extractortokenizerchat_template = Noneaudio_token = '<sound>'default_transcription_prompt = 'Transcribe the input speech.'max_audio_len = 600 )

Paramètres

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.
audio_token (Optional[str], facultatif, par défaut "<sound>") — Jeton spécial utilisé pour représenter les entrées audio dans le modèle de discussion.
default_transcription_prompt (str, facultatif, par défaut "Transcribe the input speech.") — Prompt par défaut à utiliser pour les tâches de transcription lors de l’application des requêtes de transcription.
max_audio_len (int, facultatif, valeur par défaut 600) — Longueur maximale des séquences audio, en secondes. Tout audio plus long sera tronqué.

Construit un AudioFlamingo3Processor qui encapsule un extracteur de caractéristiques et un tokenizer en un seul processeur.

AudioFlamingo3Processor offre toutes les fonctionnalités de WhisperFeatureExtractor et de Qwen2Tokenizer. Consultez ~WhisperFeatureExtractor et ~Qwen2Tokenizer pour plus d’informations.

call

< source >

( text: str | list[str]audio: typing.Union[numpy.ndarray, ForwardRef('torch.Tensor'), collections.abc.Sequence[numpy.ndarray], collections.abc.Sequence['torch.Tensor'], NoneType] = Noneoutput_labels: bool | None = False**kwargs: *<class 'transformers.models.audioflamingo3.processing_audioflamingo3.AudioFlamingo3ProcessorKwargs'> ) → BatchFeature

Paramètres

text (Union[str, list[str]]) — 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.
audio (Union[numpy.ndarray, torch.Tensor, collections.abc.Sequence[numpy.ndarray], collections.abc.Sequence[torch.Tensor]], facultatif) — L’audio ou le lot d’audios à préparer. Chaque audio peut être un tableau NumPy ou un tenseur PyTorch. Dans le cas d’un tableau NumPy/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.
output_labels (bool, facultatif, par défaut=False) — Indique s'il faut retourner les étiquettes pour l'entraînement.
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

BatchFeature

Un dictionnaire contenant le texte tokenisé (input_ids, attention_mask) et les caractéristiques audio (input_features, input_features_mask).

AudioFlamingo3Encoder

classe transformers.AudioFlamingo3Encoder

< source >

( config: AudioFlamingo3EncoderConfig )

Paramètres

config (AudioFlamingo3EncoderConfig) — 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 audio d'AudioFlamingo3, sans aucune tête ni projection 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

< source >

( input_features: Tensorinput_features_mask: typing.Optional[torch.Tensor] = None**kwargs )

Paramètres

input_features (torch.Tensor de forme (batch_size, feature_size, sequence_length)) — Fonctions Log-Mel extraites à partir de l'audio brut. Utilisez le processeur/extracteur de caractéristiques pour calculer et compléter ces caractéristiques à partir de l'entrée en forme d'onde.
input_features_mask (torch.Tensor de forme (batch_size, 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.

AudioFlamingo3Model

classe transformers.AudioFlamingo3Model

< source >

( config: AudioFlamingo3Config )

Paramètres

config (AudioFlamingo3Config) — 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 AudioFlamingo3 (encodeur Whisper fine-tuné, projecteur multi-modal, modèle de langage Qwen2), sans tête de modélisation du langage.

forward

< source >

( input_ids: typing.Optional[torch.LongTensor] = Noneinput_features: typing.Optional[torch.Tensor] = Noneinput_features_mask: typing.Optional[torch.Tensor] = 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.Tensor] = Noneuse_cache: bool | None = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → AudioFlamingo3ModelOutputWithPast or tuple(torch.Tensor)

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.Tensor de forme (batch_size, sequence_length, feature_dim), facultatif) — Les tenseurs correspondant aux caractéristiques audio d’entrée. Les caractéristiques audio peuvent être obtenues à l’aide de WhisperFeatureExtractor. Voir WhisperFeatureExtractor.call() pour plus de détails (AudioFlamingo3Processor utilise WhisperFeatureExtractor pour le traitement des audios).
input_features_mask (torch.Tensor de forme (batch_size, feature_sequence_length)) — Masque pour éviter d'appliquer l'attention aux indices de fonctionnalités de bourrage.
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.Tensor de forme (batch_size, sequence_length, hidden_size), facultatif) — Facultativement, au lieu de passer input_ids, vous pouvez choisir de passer directement une représentation intégrée. Cela est utile si vous souhaitez un meilleur contrôle sur la manière de convertir les indices input_ids en vecteurs associés 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

AudioFlamingo3ModelOutputWithPast ou tuple(torch.Tensor)

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

La méthode forward du modèle AudioFlamingo3Model surcharge 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.

audio_hidden_states (torch.Tensor, facultatif) — États cachés audio projetés.

AudioFlamingo3ForConditionalGeneration

classe transformers.AudioFlamingo3ForConditionalGeneration

< source >

( config: AudioFlamingo3Config )

Paramètres

config (AudioFlamingo3Config) — 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 AudioFlamingo3, qui se compose d'un encodeur Whisper fine-tuné, d'un projecteur multi-modal et d'un modèle de langage Qwen2.

forward

< source >

( input_ids: typing.Optional[torch.LongTensor] = Noneinput_features: typing.Optional[torch.Tensor] = Noneinput_features_mask: typing.Optional[torch.Tensor] = 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.Tensor] = Nonelabels: typing.Optional[torch.LongTensor] = Noneuse_cache: bool | None = Nonelogits_to_keep: typing.Union[int, torch.Tensor] = 0**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → AudioFlamingo3CausalLMOutputWithPast or tuple(torch.Tensor)

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.Tensor de forme (batch_size, sequence_length, feature_dim), facultatif) — Les tenseurs correspondant aux caractéristiques audio d’entrée. Les caractéristiques audio peuvent être obtenues à l’aide de WhisperFeatureExtractor. Voir WhisperFeatureExtractor.call() pour plus de détails (AudioFlamingo3Processor utilise WhisperFeatureExtractor pour le traitement des audios).
input_features_mask (torch.Tensor de forme (batch_size, feature_sequence_length)) — Masque pour éviter d'appliquer l'attention aux indices de fonctionnalités de bourrage.
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.Tensor de forme (batch_size, sequence_length, hidden_size), facultatif) — Facultativement, au lieu de passer input_ids, vous pouvez choisir de passer directement une représentation intégrée. Cela est utile si vous souhaitez un meilleur contrôle sur la manière de convertir les indices input_ids en vecteurs associés 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é.
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).
logits_to_keep (Union[int, torch.Tensor], facultatif, valeur par défaut 0) — Si c'est un int, calcule les logits pour les logits_to_keep derniers jetons. Si 0, calcule les logits pour tous les input_ids (cas particulier). Seuls les logits du dernier jeton sont nécessaires pour la génération, et les calculer uniquement pour ce jeton peut économiser de la mémoire, ce qui devient assez significatif pour les séquences longues ou les tailles de vocabulaire importantes. Si c'est un torch.Tensor, il doit être 1D et correspondre aux indices à conserver dans la dimension de la longueur de la séquence. Cela est utile lors de l'utilisation du format de tenseurs empilés (une seule dimension pour le lot et la longueur de la séquence).

Retourne

AudioFlamingo3CausalLMOutputWithPast ou tuple(torch.Tensor)

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

La méthode forward de AudioFlamingo3ForConditionalGeneration surcharge la méthode spéciale __call__.

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

loss (torch.Tensor de forme (1,), facultatif, renvoyé lorsque labels est fourni) — Perte de modélisation du langage (pour la prédiction du jeton suivant).
logits (torch.Tensor de forme (batch_size, sequence_length, config.vocab_size)) — Scores de prédiction de la tête de modélisation du langage.
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.
hidden_states (tuple[torch.Tensor], facultatif, renvoyé lorsque output_hidden_states=True est passé ou lorsque config.output_hidden_states=True) — Tuple de torch.Tensor (un pour la sortie des embeddings, si le modèle possède une couche d’embedding, + un pour la sortie de chaque couche) de forme (batch_size, sequence_length, hidden_size).

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

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.
audio_hidden_states (torch.Tensor, facultatif) — États cachés de l'encodeur audio après projection.

Exemple :

>>> from transformers import AudioFlamingo3ForConditionalGeneration, AutoProcessor

>>> model_id = "nvidia/audio-flamingo-3-hf"
>>> processor = AutoProcessor.from_pretrained(model_id)
>>> model = AudioFlamingo3ForConditionalGeneration.from_pretrained(model_id, device_map="auto")

get_audio_features

< source >

( input_featuresinput_features_mask**kwargs )

Update on GitHub

←Aria AyaVision→