Transformers documentation
Áudio-texto-para-texto
Áudio-texto-para-texto
Modelos de áudio-texto-para-texto aceitam tanto áudio quanto texto como entradas e geram texto como saída. Eles combinam a compreensão de áudio com a geração de linguagem, permitindo tarefas como resposta a perguntas sobre áudio (por exemplo, “O que está sendo dito neste clipe?”), raciocínio sobre áudio (por exemplo, “Que emoção o falante transmite?”) e compreensão de diálogos falados. Diferentemente dos modelos tradicionais de reconhecimento automático de fala (ASR), que apenas transcrevem a fala em texto, os modelos de áudio-texto-para-texto podem raciocinar sobre o conteúdo do áudio, seguir instruções complexas e produzir respostas contextuais com base no que ouvem.
O exemplo abaixo mostra como carregar um modelo e um processador, passar um arquivo de áudio com um prompt de texto e gerar uma resposta. Neste caso, pedimos ao modelo para transcrever uma gravação de fala.
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'."]Este guia mostrará como:
- Ajuste fino de Audio Flamingo 3 no conjunto de dados AudioCaps para legendagem de áudio usando LoRA.
- Use seu modelo ajustado para inferência.
Para ver todas as arquiteturas e checkpoints compatíveis com esta tarefa, recomendamos consultar a página da tarefa.
Antes de começar, verifique se você tem todas as bibliotecas necessárias instaladas:
pip install transformers datasets peft accelerate
Recomendamos que você faça login na sua conta do Hugging Face para que possa enviar e compartilhar seu modelo com a comunidade. Quando solicitado, insira seu token para fazer login:
>>> from huggingface_hub import notebook_login
>>> notebook_login()Carregar o conjunto de dados AudioCaps
Comece carregando o conjunto de dados AudioCaps da biblioteca 🤗 Datasets em modo de streaming. Este conjunto de dados contém clipes de áudio com legendas descritivas, perfeito para tarefas de legendagem de áudio.
>>> from datasets import load_dataset, Audio
>>> dataset = load_dataset("OpenSound/AudioCaps", split="train", streaming=True)Convert a coluna de áudio para 16 kHz, que é exigido pelo extrator de recursos Whisper do Audio Flamingo:
>>> dataset = dataset.cast_column("audio", Audio(sampling_rate=16000))Divida o conjunto de dados em conjuntos de treinamento e teste usando .take() e .skip() para conjuntos de dados em streaming:
>>> train_dataset = dataset.take(1000)
>>> eval_dataset = dataset.skip(1000).take(100)Dê uma olhada em um exemplo:
>>> 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 ...>}
O conjunto de dados contém:
audio: a forma de onda do áudiocaption: a legenda descritiva do áudio
Pré-processar
Carregue o processador do Audio Flamingo para lidar com entradas de áudio e texto:
>>> from transformers import AutoProcessor
>>> processor = AutoProcessor.from_pretrained("nvidia/audio-flamingo-3-hf")Crie um data collator que processa pares de áudio e texto no formato esperado pelo Audio Flamingo. O collator usa o formato de template de chat com arrays de áudio diretos:
>>> 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 o data collator:
>>> data_collator = AudioFlamingo3DataCollator(processor)Treinar
Se você não está familiarizado com o ajuste fino de um modelo usando o Trainer, confira o tutorial básico aqui!
Carregue o modelo Audio Flamingo. Usamos a precisão bfloat16 e device_map="auto" para um uso eficiente de memória:
>>> from transformers import AudioFlamingo3ForConditionalGeneration
>>> import torch
>>> model = AudioFlamingo3ForConditionalGeneration.from_pretrained(
... "nvidia/audio-flamingo-3-hf",
... torch_dtype=torch.bfloat16,
... device_map="auto",
... )Configure o LoRA
LoRA (Low-Rank Adaptation) permite o ajuste fino eficiente treinando apenas um pequeno número de parâmetros adicionais. Configure o LoRA para direcionar as camadas de atenção e feed-forward do modelo de linguagem:
>>> 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
O LoRA reduz significativamente o uso de memória e o tempo de treinamento, atualizando apenas um pequeno número de parâmetros de adaptador em vez do modelo completo. Essa configuração visa as camadas de atenção e feed-forward do modelo de linguagem, mantendo o codificador de áudio congelado, o que torna possível fazer fine-tuning em uma única GPU.
Configurar o treinamento
Defina os hiperparâmetros de treinamento em TrainingArguments. Observe que usamos max_steps em vez de épocas, pois estamos usando um conjunto de dados em 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",
... )Passe os argumentos de treinamento para o Trainer junto com o modelo, os conjuntos de dados e o data collator:
>>> trainer = Trainer(
... model=model,
... args=training_args,
... train_dataset=train_dataset,
... eval_dataset=eval_dataset,
... data_collator=data_collator,
... )
>>> trainer.train()Salve o adaptador LoRA e o processador:
>>> trainer.save_model()
>>> processor.save_pretrained("audio-flamingo-3-hf-lora-finetuned")
['audio-flamingo-3-hf-lora-finetuned/processor_config.json']
Após a conclusão do treinamento, compartilhe seu modelo no Hub:
>>> trainer.push_to_hub()Inferência
Agora que você ajustou o modelo, pode usá-lo para legendagem de áudio.
Carregue o modelo e o processador 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")Carregue uma amostra de áudio para inferência:
>>> 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"]Prepare a entrada com um formato de conversa:
>>> 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)Gerar uma resposta:
>>> 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 inferência rápida, use a API Pipeline com um modelo any-to-any. O exemplo abaixo usa o Voxtral, que aceita entradas de áudio e texto e gera texto. Consulte o guia da tarefa any-to-any para mais exemplos.
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"])Leituras adicionais
- A página da tarefa de áudio-texto-para-texto aborda os tipos de modelo, casos de uso e conjuntos de dados.
- Documentação do PEFT para mais opções de configuração do LoRA e outros métodos de adaptador.
- cartão do modelo Audio Flamingo 3 para detalhes e capacidades específicos do modelo.