Written with AI assistance from the source video. The video is the authority.
Log in to leave a comment
No posts yet
Les petits modèles multimodaux à poids ouverts ont abaissé les barrières à l'apprentissage des données d'entreprise. Cependant, les arrêts d'entraînement en cours de route dus à des erreurs de calcul de la VRAM ou à des omissions de prétraitement audio se répètent fréquemment. De l'estimation du budget matériel au pipeline de prétraitement audio et aux étapes de validation des performances, nous passons en revue les méthodes d'exécution qui fonctionnent directement dans la pratique.
Pour éviter les erreurs de mémoire insuffisante, l'occupation totale de la VRAM () doit être calculée directement comme la somme des paramètres du modèle, des gradients, des états de l'optimiseur, des activations et de la surcharge du framework.
L'optimiseur AdamW standard stocke le premier moment et la variance du second moment par paramètre d'apprentissage en précision FP32, consommant ainsi . L'application de la bibliothèque 8-bit AdamW réduit cette exigence à environ 6 octets par paramètre. Le fine-tuning complet d'un modèle de 8 milliards de paramètres en précision FP16 nécessite environ 120 Go à 140 Go de VRAM. C'est la raison pour laquelle l'utilisation de plusieurs cartes A100 de 80 Go est imposée.
Pour économiser le budget dans un environnement à GPU unique, procédez comme suit :
L'intégration directe de données audio brutes bruitées dans l'encodeur multimodal fait osciller la fonction de perte. Conformément à la norme EBU R128, ajustez le volume intégré à -23 LUFS dans une marge d'erreur de 1 LUFS ou définissez le pic maximal à -1,0 dBFS pour éviter l'explosion des gradients.
Fixez la fréquence d'échantillonnage () à 16000 Hz et définissez la taille de la fenêtre FFT à 2048 échantillons. Spécifiez hop_length à 512 échantillons pour maintenir le chevauchement de fenêtres entre 60% et 75%, créant ainsi 100 frames par seconde. Appliquez 128 canaux au banc de filtres Mel et effectuez une compression logarithmique.
Pour éviter les arrêts anormaux dus aux tenseurs NaN pendant l'apprentissage, placez le script de validation ci-dessous au début du 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
`
Le taux d'apprentissage doit être défini différemment selon la structure du modèle. Réglez-le entre et pour le fine-tuning complet, entre et pour LoRA avec un rang , et entre et pour QLoRA. Insérez un Linear Warmup pendant 3% à 5% des étapes totales, puis atténuez-le avec un Cosine Decay.
Même si vous réduisez la taille du batch à 4, maintenez gradient_accumulation_steps à 8 pour préserver une taille de batch effective de 32. Pour éviter le surapprentissage, appliquez directement la configuration HuggingFace Trainer ci-dessous.
`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" et eval_steps=100 pour suivre la perte toutes les 100 étapes.load_best_model_at_end=True pour conserver automatiquement les poids qui ont donné la perte de validation la plus faible.early_stopping_patience=3 à EarlyStoppingCallback pour arrêter immédiatement les calculs si la perte de validation ne s'améliore pas 3 fois de suite.Avant de déployer le modèle, vous devez vérifier la qualité des réponses à l'aide de 10 invites spécifiques au domaine. Effectuez la localisation de la chronologie audio, l'extraction de texte en environnement bruyant, l'analyse de l'état des objets visuels, la simultanéité des événements visuels et audio, les instructions multimodales à tours multiples, le traitement de la terminologie spécialisée du domaine, l'inférence d'événements acoustiques non vocaux, la reconnaissance des relations spatiales, la vérification de l'induction d'hallucinations hors domaine et le test de sortie JSON de données structurées.
Les hallucinations d'objets sont mesurées à l'aide des frameworks CHAIR et POPE.
CHAIR_i = rac{ ext{Nombre d'instances d'objets hallucinés}}{ ext{Nombre total d'instances d'objets mentionnés}}CHAIR_s = rac{ ext{Nombre de légendes contenant au moins 1 objet halluciné}}{ ext{Nombre total de légendes évaluées}}Dans le framework POPE, la précision des réponses par OUI ou NON est mesurée via des requêtes d'échantillonnage aléatoire, populaire et contradictoire. Avant de passer en production, vérifiez l'obtention d'un temps de génération du premier token inférieur à 800 ms, le maintien d'une vitesse de génération de 30 tokens par seconde et le respect de la spécification de sortie JSON après conversion vLLM.