Written with AI assistance from the source video. The video is the authority.
Log in to leave a comment
No posts yet
Os modelos multimodais de pesos abertos de pequeno porte reduziram a barreira para o treinamento com dados de negócios. No entanto, interrupções no treinamento continuam ocorrendo devido a erros de cálculo de VRAM ou omissões no pré-processamento de áudio. Abordaremos métodos práticos que funcionam no dia a dia, desde a estimativa de orçamento de hardware até o pipeline de pré-processamento de áudio e etapas de validação de desempenho.
Para evitar erros de falta de memória, o consumo total de VRAM () deve ser calculado diretamente como a soma dos parâmetros do modelo, gradientes, estados do otimizador, ativações e sobrecarga do framework.
O otimizador AdamW padrão armazena o primeiro momento e a variância do segundo momento por parâmetro de treinamento com precisão FP32, consumindo assim . A aplicação da biblioteca AdamW de 8 bits reduz esse requisito para cerca de 6 bytes por parâmetro. O fine-tuning completo de um modelo de 8B parâmetros em precisão FP16 requer aproximadamente 120GB a 140GB de VRAM, razão pela qual múltiplos dispositivos A100 de 80GB são obrigatórios.
Para economizar orçamento em um ambiente de GPU única, siga o procedimento abaixo:
Alimentar diretamente um codificador multimodal com áudio bruto contendo ruído fará com que a função de perda flutue. De acordo com o padrão EBU R128, ajuste o volume integrado para -23 LUFS dentro de uma margem de erro de 1 LUFS ou defina o pico máximo para -1.0 dBFS para evitar a explosão de gradientes.
Fixe a taxa de amostragem () em 16000 Hz e defina o tamanho da janela FFT para 2048 amostras. Especifique o hop_length como 512 amostras para manter a sobreposição da janela entre 60% e 75%, gerando 100 quadros por segundo. Aplique 128 canais para o banco de filtros Mel e realize a compressão logarítmica.
Para evitar o término anormal devido a tensores NaN durante o treinamento, coloque o script de validação abaixo no início do pipeline.
`python
import os
import json
import torch
import torchaudio
from PIL import Image
def validate_multimodal_dataset(jsonl_path, min_audio_len=0.5, max_audio_len=30.0):
valid_records = []
corrupted_count = 0
with open(jsonl_path, 'r', encoding='utf-8') as f:
lines = f.readlines()
for idx, line in enumerate(lines):
try:
data = json.loads(line.strip())
audio_path = data.get("audio_path")
image_path = data.get("image_path")
text_label = data.get("text")
if not text_label or not isinstance(text_label, str) or len(text_label.strip()) == 0:
raise ValueError("Empty or invalid text label.")
if audio_path and os.path.exists(audio_path):
info = torchaudio.info(audio_path)
duration = info.num_frames / info.sample_rate
if duration < min_audio_len or duration > max_audio_len:
raise ValueError(f"Audio duration {duration:.2f}s out of bounds.")
waveform, sr = torchaudio.load(audio_path)
if torch.isnan(waveform).any() or torch.isinf(waveform).any():
raise ValueError("Audio contains NaN/Inf values.")
elif audio_path:
raise FileNotFoundError(f"Audio path not found: {audio_path}")
if image_path and os.path.exists(image_path):
with Image.open(image_path) as img:
img.verify()
with Image.open(image_path) as img:
img.convert("RGB")
width, height = img.size
if width < 10 or height < 10:
raise ValueError(f"Image resolution too small: {width}x{height}")
elif image_path:
raise FileNotFoundError(f"Image path not found: {image_path}")
valid_records.append(data)
except Exception as e:
corrupted_count += 1
return valid_records
`
A taxa de aprendizado deve ser definida de forma diferente dependendo da estrutura do modelo. Configure o fine-tuning completo entre e , LoRA com rank entre e , e QLoRA entre e . Insira um Linear Warmup durante 3% a 5% dos passos totais e, em seguida, atenue com Cosine Decay.
Mesmo se você reduzir o tamanho do lote para 4, defina gradient_accumulation_steps como 8 para manter o tamanho efetivo do lote em 32. Para evitar overfitting, aplique a configuração do HuggingFace Trainer abaixo.
`python
from transformers import (
Trainer,
TrainingArguments,
EarlyStoppingCallback
)
training_args = TrainingArguments(
output_dir="./fine_tuned_multimodal_checkpoints",
num_train_epochs=5,
per_device_train_batch_size=4,
per_device_eval_batch_size=4,
gradient_accumulation_steps=8,
learning_rate=2e-4,
weight_decay=0.01,
warmup_ratio=0.03,
lr_scheduler_type="cosine",
logging_steps=10,
eval_strategy="steps",
eval_steps=100,
save_strategy="steps",
save_steps=100,
save_total_limit=3,
load_best_model_at_end=True,
metric_for_best_model="eval_loss",
greater_is_better=False,
fp16=True,
report_to="wandb"
)
trainer = Trainer(
model=model,
args=training_args,
train_dataset=train_dataset,
eval_dataset=val_dataset,
data_collator=data_collator,
callbacks=[
EarlyStoppingCallback(
early_stopping_patience=3,
early_stopping_threshold=0.001
)
]
)
trainer.train()
`
eval_strategy="steps" e eval_steps=100 para rastrear a perda a cada 100 passos.load_best_model_at_end=True para salvar automaticamente os pesos que obtiveram a menor perda de validação.early_stopping_patience=3 ao EarlyStoppingCallback para interromper imediatamente a computação se a perda de validação não melhorar por 3 vezes consecutivas.Antes de implantar o modelo, a qualidade das respostas deve ser verificada com 10 prompts especializados de domínio. Realize testes de localização de eixo temporal de áudio, extração de texto em ambiente ruidoso, análise de estado de objeto visual, simultaneidade de eventos visuais e áudio, instruções multimodais de turnos complexos, processamento de terminologia especializada de domínio, inferência de eventos acústicos não vocais, reconhecimento de relações espaciais, validação de indução de alucinação fora do domínio e saída JSON de dados estruturados.
A alucinação de objetos é medida pelas frameworks CHAIR e POPE.
CHAIR_i = rac{ ext{Número de instâncias de objetos alucinados}}{ ext{Número total de instâncias de objetos mencionados}}CHAIR_s = rac{ ext{Número de legendas contendo 1 ou mais objetos alucinados}}{ ext{Número total de legendas avaliadas}}Na framework POPE, a precisão das respostas do tipo sim ou não é medida por meio de consultas de Amostragem Aleatória, Popular e Adversarial. Antes de colocar em um ambiente de produção, confirme finalmente se o tempo de geração do primeiro token é garantido em até 800ms, se a velocidade de geração de tokens por segundo é mantida em 30 tokens e se a especificação de saída JSON é mantida após a conversão para vLLM.