Transformers documentation
Audio-texte-vers-texte
Audio-texte-vers-texte
Les modèles audio-texte-vers-texte acceptent à la fois de l’audio et du texte en entrée et génèrent du texte en sortie. Ils combinent la compréhension audio et la génération de langage, permettant des tâches telles que la question-réponse audio (par exemple, « Que dit-on dans cet extrait ? »), le raisonnement audio (par exemple, « Quelle émotion le locuteur exprime-t-il ? ») et la compréhension des dialogues oraux. Contrairement aux modèles traditionnels de reconnaissance automatique de la parole (ASR) qui se limitent à transcrire la parole en texte, les modèles audio-texte-vers-texte peuvent raisonner sur le contenu audio, suivre des instructions complexes et produire des réponses contextuelles basées sur ce qu’ils entendent.
L'exemple ci-dessous montre comment charger un modèle et un processeur, passer un fichier audio avec un prompt texte, et générer une réponse. Dans ce cas, nous demandons au modèle de transcrire un enregistrement vocal.
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)
outputs = model.generate(**inputs, max_new_tokens=500)
decoded_outputs = processor.batch_decode(outputs[:, inputs.input_ids.shape[1]:], skip_special_tokens=True)
print(decoded_outputs)
## ["The transcription of the audio is 'summer follows spring the days grow longer and the nights are warm'."]Ce guide vous montre comment :
- Effectuer un fine-tuning de Audio Flamingo 3 sur le jeu de données AudioCaps pour la légende audio en utilisant LoRA.
- Utilisez votre modèle affiné pour l'inférence.
Pour consulter toutes les architectures et points de contrôle compatibles avec cette tâche, nous vous recommandons de consulter la page de la tâche.
Avant de commencer, assurez-vous d'avoir installé toutes les bibliothèques nécessaires :
pip install transformers datasets peft accelerate
Nous vous encourage à vous connecter à votre compte Hugging Face afin de pouvoir téléverser et partager votre modèle avec la communauté. Lorsque cela vous est demandé, saisissez votre jeton pour vous connecter :
>>> from huggingface_hub import notebook_login
>>> notebook_login()Charger le jeu de données AudioCaps
Commencez par charger le jeu de données AudioCaps depuis la bibliothèque 🤗 Datasets en mode streaming. Ce jeu de données contient des extraits audio avec des légendes descriptives, idéal pour les tâches de légendage audio.
>>> from datasets import load_dataset, Audio
>>> dataset = load_dataset("OpenSound/AudioCaps", split="train", streaming=True)Caster la colonne audio en 16 kHz, ce qui est requis par le feature extractor Whisper d'Audio Flamingo :
>>> dataset = dataset.cast_column("audio", Audio(sampling_rate=16000))Diviser le jeu de données en ensembles d’entraînement et de test à l’aide de .take() et .skip() pour les jeux de données en streaming :
>>> train_dataset = dataset.take(1000)
>>> eval_dataset = dataset.skip(1000).take(100)Voici un exemple :
>>> next(iter(train_dataset))
{'audiocap_id': 91139, 'youtube_id': 'r1nicOVtvkQ', 'start_time': 130, 'caption': 'A woman talks nearby as water pours', 'audio_length': 480000, 'audio': <datasets.features._torchcodec.AudioDecoder object at ...>}
Le jeu de données contient :
audio: la forme d'onde audiocaption: la légende descriptive de l'audio
Prétraitement
Chargez le processeur Audio Flamingo pour gérer à la fois les entrées audio et texte :
>>> from transformers import AutoProcessor
>>> processor = AutoProcessor.from_pretrained("nvidia/audio-flamingo-3-hf")Créez un collateur de données qui traite les paires audio-texte dans le format attendu par Audio Flamingo. Le collateur utilise le format de modèle de discussion avec des tableaux audio directs :
>>> class AudioFlamingo3DataCollator:
... """Data collator for Audio Flamingo 3 audio captioning training."""
...
... def __init__(self, processor):
... self.processor = processor
...
... def __call__(self, features):
... conversations = []
...
... for feature in features:
... # Build conversation format for Audio Flamingo
... # Audio is passed directly as an array, no base64 encoding needed
... sample = [
... {
... "role": "user",
... "content": [
... {"type": "text", "text": "Describe the audio."},
... {"type": "audio", "audio": feature["audio"].get_all_samples().data[0].numpy()},
... ],
... },
... {
... "role": "assistant",
... "content": [{"type": "text", "text": feature["caption"]}],
... }
... ]
... conversations.append(sample)
...
... # Apply chat template and format labels for training
... return self.processor.apply_chat_template(
... conversations,
... tokenize=True,
... add_generation_prompt=False,
... return_dict=True,
... output_labels=True, # Automatically creates labels for training
... )Instanciez le collateur de données :
>>> data_collator = AudioFlamingo3DataCollator(processor)Entraînement
Si vous n’êtes pas familier avec l’ajustement fin d’un modèle à l’aide du Trainer, consultez le tutoriel de base ici !
Chargez le modèle Audio Flamingo. Nous utilisons la précision bfloat16 et device_map="auto" pour une utilisation efficace de la mémoire :
>>> from transformers import AudioFlamingo3ForConditionalGeneration
>>> import torch
>>> model = AudioFlamingo3ForConditionalGeneration.from_pretrained(
... "nvidia/audio-flamingo-3-hf",
... torch_dtype=torch.bfloat16,
... device_map="auto",
... )Configurer LoRA
LoRA (Low-Rank Adaptation) permet un fine-tuning efficace en n’entraînant qu’un petit nombre de paramètres supplémentaires. Configurez LoRA pour cibler les couches d’attention et de feed-forward du modèle de langage :
>>> from peft import LoraConfig, get_peft_model
>>> lora_config = LoraConfig(
... r=16, # LoRA rank
... lora_alpha=32, # LoRA scaling factor
... target_modules=[
... # Language model attention
... "q_proj",
... "k_proj",
... "v_proj",
... "o_proj",
... # Feed-forward layers
... "gate_proj",
... "up_proj",
... "down_proj",
... ],
... lora_dropout=0.05,
... bias="none",
... task_type="CAUSAL_LM",
... )
>>> model = get_peft_model(model, lora_config)
>>> model.print_trainable_parameters()
trainable params: 44,302,336 || all params: 8,311,517,696 || trainable%: 0.5330
LoRA réduit considérablement la consommation de mémoire et le temps d’entraînement en ne mettant à jour qu’un petit nombre de paramètres d’adaptateurs plutôt que le modèle complet. Cette configuration cible les couches d’attention et de réseau de neurones à propagation avant du modèle de langage, tout en gardant l’encodeur audio figé, ce qui permet d’effectuer un fine-tuning sur un seul GPU.
Configurer l'entraînement
Définissez les hyperparamètres d’entraînement dans TrainingArguments. Notez que nous utilisons max_steps au lieu d’époques, car nous travaillons avec un jeu de données en flux continu :
>>> from transformers import TrainingArguments, Trainer
>>> training_args = TrainingArguments(
... output_dir="audio-flamingo-3-hf-lora-finetuned",
... per_device_train_batch_size=4,
... per_device_eval_batch_size=4,
... gradient_accumulation_steps=4,
... learning_rate=1e-4,
... max_steps=500, # Use max_steps with streaming datasets
... bf16=True,
... logging_steps=10,
... eval_steps=100,
... save_steps=250,
... save_total_limit=2, # Keep only the latest 2 checkpoints
... save_only_model=True, # Skip saving optimizer state to save disk space
... eval_strategy="steps",
... save_strategy="steps",
... remove_unused_columns=False,
... dataloader_num_workers=0, # Must be 0 for streaming datasets
... gradient_checkpointing=True,
... report_to="none",
... )Transmettez les arguments d’entraînement à Trainer en même temps que le modèle, les jeux de données et le data collator :
>>> trainer = Trainer(
... model=model,
... args=training_args,
... train_dataset=train_dataset,
... eval_dataset=eval_dataset,
... data_collator=data_collator,
... )
>>> trainer.train()Enregistrez l'adaptateur LoRA et le processeur :
>>> trainer.save_model()
>>> processor.save_pretrained("audio-flamingo-3-hf-lora-finetuned")
['audio-flamingo-3-hf-lora-finetuned/processor_config.json']
Une fois l’entraînement terminé, partagez votre modèle sur le Hub :
>>> trainer.push_to_hub()Inférence
Maintenant que vous avez affiné le modèle, vous pouvez l’utiliser pour la légende audio.
Chargez le modèle et le processeur affinés :
>>> from transformers import AudioFlamingo3ForConditionalGeneration, AutoProcessor
>>> from peft import PeftModel
>>> import torch
>>> base_model = AudioFlamingo3ForConditionalGeneration.from_pretrained(
... "nvidia/audio-flamingo-3-hf",
... torch_dtype=torch.bfloat16,
... device_map="auto",
... )
>>> model = PeftModel.from_pretrained(base_model, "audio-flamingo-3-hf-lora-finetuned")
>>> processor = AutoProcessor.from_pretrained("audio-flamingo-3-hf-lora-finetuned")Charger un échantillon audio pour l'inférence :
>>> from datasets import load_dataset, Audio
>>> dataset = load_dataset("OpenSound/AudioCaps", split="test", streaming=True)
>>> dataset = dataset.cast_column("audio", Audio(sampling_rate=16000))
>>> sample = next(iter(dataset))
>>> audio = sample["audio"]
>>> audio_array = audio.get_all_samples().data[0].numpy() if hasattr(audio, "get_all_samples") else audio["array"]Préparez l’entrée au format de conversation :
>>> messages = [
... {
... "role": "user",
... "content": [
... {"type": "text", "text": "Describe the audio."},
... {"type": "audio", "audio": audio_array},
... ],
... }
... ]
>>> inputs = processor.apply_chat_template(
... messages,
... tokenize=True,
... add_generation_prompt=True,
... return_dict=True,
... ).to(device=model.device, dtype=model.dtype)Générer une réponse :
>>> with torch.no_grad():
... output_ids = model.generate(**inputs, max_new_tokens=100)
>>> # Decode only the generated tokens
>>> input_len = inputs["input_ids"].shape[1]
>>> response = processor.tokenizer.decode(output_ids[0][input_len:], skip_special_tokens=True)
>>> print(response)
## A sewing machine is running while people are talkingPipeline
Pour une inférence rapide, utilisez l’API Pipeline avec un modèle any-to-any. L’exemple ci-dessous utilise Voxtral, qui accepte des entrées audio et texte et génère du texte. Consultez le guide de la tâche any-to-any pour plus d’exemples.
from transformers import pipeline
pipe = pipeline("any-to-any", model="mistralai/Voxtral-Mini-3B-2507")
messages = [
{
"role": "user",
"content": [
{
"type": "audio",
"url": "https://huggingface.co/datasets/raushan-testing-hf/audio-test/resolve/main/glass-breaking-151256.mp3",
},
{"type": "text", "text": "What do you hear in this audio?"},
],
},
]
outputs = pipe(text=messages, max_new_tokens=100, return_full_text=False)
print(outputs[0]["generated_text"])Lecture complémentaire
- La page de la tâche audio-texte-vers-texte présente les types de modèles, les cas d’usage et les jeux de données.
- documentation PEFT pour plus d'options de configuration de LoRA et d'autres méthodes d'adaptateurs.
- fiche du modèle Audio Flamingo 3 pour les détails et les capacités spécifiques au modèle.