Transformers documentation
Audio-texto-a-texto
Audio-texto-a-texto
Los modelos de audio-texto-a-texto aceptan tanto audio como texto como entradas y generan texto como salida. Combinan la comprensión del audio con la generación de lenguaje, lo que permite realizar tareas como la respuesta a preguntas sobre audio (por ejemplo, “¿Qué se está diciendo en este clip?”), el razonamiento sobre audio (por ejemplo, “¿Qué emoción transmite el hablante?”) y la comprensión de diálogos hablados. A diferencia de los modelos tradicionales de reconocimiento automático del habla (ASR) que solo transcriben el habla a texto, los modelos de audio-texto-a-texto pueden razonar sobre el contenido del audio, seguir instrucciones complejas y generar respuestas contextualizadas basadas en lo que escuchan.
El siguiente ejemplo muestra cómo cargar un modelo y un procesador, pasar un archivo de audio con un prompt de texto y generar una respuesta. En este caso, le pedimos al modelo que transcriba una grabación de voz.
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'."]Esta guía le mostrará cómo:
- Ajusta el modelo Audio Flamingo 3 en el conjunto de datos AudioCaps para la generación de descripciones de audio, utilizando LoRA.
- Usa tu modelo afinado para la inferencia.
Para ver todas las arquitecturas y puntos de control compatibles con esta tarea, recomendamos consultar la página de la tarea.
Antes de comenzar, asegúrate de tener instaladas todas las bibliotecas necesarias:
pip install transformers datasets peft accelerate
Te animamos a iniciar sesión en tu cuenta de Hugging Face para que puedas subir y compartir tu modelo con la comunidad. Cuando se te solicite, introduce tu token para iniciar sesión:
>>> from huggingface_hub import notebook_login
>>> notebook_login()Cargar el conjunto de datos AudioCaps
Comience cargando el conjunto de datos AudioCaps desde la biblioteca 🤗 Datasets en modo de streaming. Este conjunto de datos contiene clips de audio con descripciones, ideal para tareas de descripción de audio.
>>> from datasets import load_dataset, Audio
>>> dataset = load_dataset("OpenSound/AudioCaps", split="train", streaming=True)Convierte la columna de audio a 16 kHz, que es lo que requiere el extractor de características Whisper de Audio Flamingo:
>>> dataset = dataset.cast_column("audio", Audio(sampling_rate=16000))Divida el conjunto de datos en conjuntos de entrenamiento y prueba usando .take() y .skip() para conjuntos de datos de streaming:
>>> train_dataset = dataset.take(1000)
>>> eval_dataset = dataset.skip(1000).take(100)Echa un vistazo a un ejemplo:
>>> 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 ...>}
El conjunto de datos contiene:
audio: la forma de onda de audiocaption: el texto descriptivo de la transcripción del audio
Preprocesar
Cargue el procesador de Audio Flamingo para manejar tanto entradas de audio como de texto:
>>> from transformers import AutoProcessor
>>> processor = AutoProcessor.from_pretrained("nvidia/audio-flamingo-3-hf")Cree un collator de datos que procese pares de audio y texto en el formato esperado por Audio Flamingo. El collator utiliza el formato de plantilla de chat con matrices de audio directas:
>>> 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
... )Instancie el data collator:
>>> data_collator = AudioFlamingo3DataCollator(processor)Entrenar
Si no estás familiarizado con el ajuste fino de un modelo con Trainer, ¡echa un vistazo al tutorial básico aquí!
Cargue el modelo Audio Flamingo. Utilizamos la precisión bfloat16 y device_map="auto" para un uso eficiente de la memoria:
>>> from transformers import AudioFlamingo3ForConditionalGeneration
>>> import torch
>>> model = AudioFlamingo3ForConditionalGeneration.from_pretrained(
... "nvidia/audio-flamingo-3-hf",
... torch_dtype=torch.bfloat16,
... device_map="auto",
... )Configurar LoRA
LoRA (Low-Rank Adaptation) permite un ajuste fino eficiente al entrenar solo un pequeño número de parámetros adicionales. Configure LoRA para que apunte a las capas de atención y de avance hacia adelante del modelo de lenguaje:
>>> 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 reduce significativamente el uso de memoria y el tiempo de entrenamiento al actualizar solo un pequeño número de parámetros de adaptador en lugar del modelo completo. Esta configuración apunta a las capas de atención y de red feed-forward del modelo de lenguaje, manteniendo el codificador de audio congelado, lo que permite realizar el ajuste fino en una sola GPU.
Configurar el entrenamiento
Defina los hiperparámetros de entrenamiento en TrainingArguments. Tenga en cuenta que usamos max_steps en lugar de epochs, ya que estamos utilizando un conjunto de datos de streaming:
>>> 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",
... )Pasa los argumentos de entrenamiento a Trainer junto con el modelo, los conjuntos de datos y el data collator:
>>> trainer = Trainer(
... model=model,
... args=training_args,
... train_dataset=train_dataset,
... eval_dataset=eval_dataset,
... data_collator=data_collator,
... )
>>> trainer.train()Guarde el adaptador LoRA y el procesador:
>>> trainer.save_model()
>>> processor.save_pretrained("audio-flamingo-3-hf-lora-finetuned")
['audio-flamingo-3-hf-lora-finetuned/processor_config.json']
Una vez completado el entrenamiento, comparte tu modelo en el Hub:
>>> trainer.push_to_hub()Inferencia
Ahora que has ajustado el modelo, puedes usarlo para la descripción de audio.
Cargue el modelo y el procesador ajustados:
>>> 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")Cargue una muestra de audio para la inferencia:
>>> 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"]Prepara la entrada con un formato de conversación:
>>> 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)Generar una respuesta:
>>> 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
Para una inferencia rápida, use la API Pipeline con un modelo any-to-any. El ejemplo siguiente utiliza Voxtral, que acepta entradas de audio y texto y genera texto. Consulte la guía de la tarea any-to-any para más ejemplos.
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"])Lecturas adicionales
- La página de la tarea de audio-texto a texto cubre los tipos de modelos, los casos de uso y los conjuntos de datos.
- Documentación de PEFT para más opciones de configuración de LoRA y otros métodos de adaptadores.
- ficha del modelo Audio Flamingo 3 para conocer los detalles y capacidades específicos del modelo.