Alors que les grands modèles de langage (LLM) évoluent, ils ne sont plus limités au texte. L'émergence de modèles Vision-Langage (VLM) comme GPT-4V, LLaVA et Gemini Pro a débloqué de nouvelles capacités, permettant à l'IA d'interpréter des images, des graphiques et des captures d'écran. Cependant, l'évaluation de ces modèles est considérablement plus complexe que la génération de texte standard. Vous ne pouvez pas simplement utiliser des scores BLEU ou des correspondances de chaînes de caractères basiques. Vous avez besoin d'outils d'observabilité personnalisés et robustes pour vous assurer que vos applications multimodales sont fiables et précises.
Dans ce guide, nous explorerons comment Braintrust, une plateforme leader en observabilité et évaluation IA, peut être utilisée pour évaluer les VLM à l'aide de métriques personnalisées. Nous nous concentrerons sur la création de critères d'évaluation spécifiques pour les tâches visuelles, telles que la précision de la détection d'objets et la qualité des légendes, afin de garantir que votre déploiement repose sur des données de performance réelles.
Pourquoi les métriques standard échouent pour les modèles Vision-Langage
Les métriques NLP traditionnelles comme la Perplexité ou ROUGE sont conçues pour les tâches texte-vers-texte. Lorsque vous introduisez des données visuelles, l'espace d'entrée devient vaste et ambigu. Par exemple, un modèle peut identifier correctement un objet mais échouer à décrire sa relation spatiale avec un autre objet. Un simple booléen « correct » ou « incorrect » est insuffisant.
Braintrust permet aux développeurs de définir des métriques personnalisées qui s'alignent sur la logique métier spécifique. C'est crucial pour les VLM car la « justesse » d'une sortie dépend souvent du contexte de l'image. En utilisant Braintrust, vous pouvez enregistrer à la fois l'entrée image et la sortie texte du modèle, puis appliquer des fonctions de notation personnalisées pour évaluer les nuances que les benchmarks standard manquent.
Configuration des métriques personnalisées dans Braintrust
L'API de Braintrust permet de définir facilement des évaluateurs personnalisés. Vous pouvez écrire des fonctions Python qui prennent en entrée l'image, la vérité terrain attendue (si disponible) et la sortie du modèle, et qui retournent un score structuré. Regardons un exemple pratique : évaluer la capacité d'un VLM à compter les objets dans une image.
import braintrust
from PIL import Image
import re
def count_accuracy(input, output, ground_truth):
"""
Métrique personnalisée pour évaluer si le modèle a correctement compté les objets.
Args:
input: L'objet image original.
output: La réponse texte du VLM.
ground_truth: Le nombre connu d'objets (ex. : 5).
Returns:
Un dictionnaire avec 'score' et 'raisonnement'.
"""
# Extraire le premier entier trouvé dans la sortie du modèle
match = re.search(r'\d+', output)
if not match:
return {
'score': 0,
'reasoning': 'Aucun nombre trouvé dans la sortie.'
}
predicted_count = int(match.group())
if predicted_count == ground_truth:
return {
'score': 1,
'reasoning': f'{predicted_count} objets correctement identifiés.'
}
else:
# Crédit partiel si proche ? Ou juste 0 pour la rigueur ?
# Ici nous utilisons 0/1 strict, mais vous pourriez utiliser 1 - abs(diff)/max
return {
'score': 0,
'reasoning': f'Le modèle a prédit {predicted_count}, attendu {ground_truth}.'
}
# Enregistrer la métrique personnalisée
braintrust.log(
'VLM_Count_Test',
metrics={
'count_accuracy': count_accuracy
}
)
Mise en œuvre du flux de travail d'évaluation
Une fois votre métrique personnalisée définie, vous pouvez exécuter une évaluation sur un jeu de données d'images. Braintrust suit automatiquement le coût, la latence et l'utilisation des jetons de chaque requête, vous offrant une vue d'ensemble des performances de votre VLM. Voici comment vous pourriez structurer l'exécution de l'évaluation :
import base64
def encode_image(image_path):
with open(image_path, "rb") as image_file:
return base64.b64encode(image_file.read()).decode('utf-8')
# Structure d'exemple du jeu de données
dataset = [
{
"input": {
"image": "path/to/dogs.jpg",
"prompt": "Combien de chiens y a-t-il dans cette image ?"
},
"expected": 3
},
{
"input": {
"image": "path/to/cats.png",
"prompt": "Combien de chats y a-t-il dans cette image ?"
},
"expected": 1
}
]
def model_call(input):
# En supposant que vous avez un point d'accès VLM compatible OpenAI
image_b64 = encode_image(input['image'])
response = openai.chat.completions.create(
model="gpt-4-vision-preview",
messages=[
{
"role": "user",
"content": [
{"type": "text", "text": input['prompt']},
{"type": "image_url", "image_url": {"url": f"data:image/jpeg;base64,{image_b64}"}},
],
}
],
)
return response.choices[0].message.content
# Exécuter l'évaluation
braintrust.run(
"VLM_Count_Eval",
tasks=dataset,
model=model_call,
metrics={
'count_accuracy': count_accuracy,
'latency': braintrust.latency,
'cost': braintrust.cost
}
)
Visualisation des résultats et itération
Après l'exécution de l'évaluation, le tableau de bord Braintrust affichera votre métrique personnalisée count_accuracy aux côtés du coût et de la latence. Vous pouvez filtrer les résultats pour voir quels types d'images posent problème au modèle. Peut-être qu'il fonctionne bien sur des photos de studio claires mais échoue sur des vues de rue réelles et bruitées. Cette granularité d'analyse est inestimable pour améliorer votre ingénierie de prompts ou l'ajustement fin de votre modèle.
Conclusion
L'évaluation des modèles Vision-Langage nécessite de dépasser les métriques NLP génériques. En exploitant le système flexible de métriques personnalisées de Braintrust, les développeurs peuvent créer des pipelines d'évaluation spécifiques à leur cas d'usage. Que vous comptiez des objets, extrayiez du texte de captures d'écran ou interprétiez des images médicales, les métriques personnalisées fournissent la précision nécessaire pour faire confiance à votre IA en production. Commencez par définir vos critères de succès, codez votre évaluateur personnalisé et laissez les données guider votre optimisation.