Parcourir les aide-mémoire · Ingénierie IA pour les données
Choisir le bon modèle d’IA
Une méthode pratique pour choisir un modèle d’IA pour une application de données : quand ne pas utiliser de LLM, les critères qui comptent, un arbre de décision et l’évaluation des candidats sur la qualité, la latence et le coût par tâche réussie.
Sur cette page
- Problème
- Réponse rapide
- D’abord : faut-il vraiment un modèle ?
- Critères de comparaison
- Arbre de décision
- Code / commandes
- 1. Construire d’abord un jeu d’évaluation
- 2. Noter les candidats sur les mêmes cas
- 3. Comparer sur le coût par tâche réussie
- 4. Exiger une sortie structurée et la valider
- 5. Cascade : petit modèle d’abord, escalade en cas d’échec
- 6. Ajouter récupération ou outils pour les données privées et récentes
- 7. Entrées multimodales
- 8. Vérifier le débit et les limites
- 9. La taille de la fenêtre de contexte ne garantit pas la qualité
- 10. Figer les versions et réévaluer à chaque changement
- Interpréter le résultat
- Points à vérifier
- Erreurs fréquentes
- 1. Utiliser un LLM pour un travail déterministe
- 2. Choisir d’après les seuls classements publics
- 3. Prendre par défaut le plus gros modèle
- 4. Prendre par défaut le modèle le moins cher
- 5. Attendre du modèle qu’il connaisse vos données privées
- 6. Faire confiance à la sortie sans validation
- 7. N’évaluer qu’une fois
- Notes de production
- Liste de contrôle
- Étape suivante
- Pour aller plus loin
Problème
Vous avez besoin d’un modèle pour une tâche de données : extraire des champs de documents, classer des tickets, générer du SQL, résumer des incidents, répondre à des questions sur des données internes.
Les options sont nombreuses : petits et grands modèles, modèles de raisonnement, modèles multimodaux, modèles d’embedding, hébergés ou auto-hébergés. Chacun arbitre entre qualité, latence, coût, débit et effort d’exploitation.
Aucun modèle n’est le meilleur choix pour toutes les tâches. Le bon choix est l’option la moins chère et la plus rapide qui atteint votre niveau de qualité sur vos propres données, et parfois cette option n’est pas un LLM.
Réponse rapide
La tâche est-elle déterministe (analyser, formater, calculer, rechercher) ?
→ code classique, SQL, règles ou parseur. Pas de LLM.
Extraction ou classification simple, gros volume ?
→ modèle plus petit et moins cher + sortie structurée + validation.
Raisonnement complexe, entrée ambiguë, analyse en plusieurs étapes ?
→ modèle plus grand ou de raisonnement ; mesurez latence et coût.
Besoin de données actuelles, privées ou métier ?
→ modèle + récupération (RAG) ou outils. Le modèle ne « connaît » pas vos données.
Besoin d'une sortie exacte, lisible par une machine ?
→ sortie structurée + validation de schéma + nouvelle tentative ou escalade.
L'entrée contient des images, des scans, des graphiques ?
→ modèle multimodal, ou OCR/analyse d'abord puis modèle texte.
Confirmez ensuite avec un jeu d’évaluation : précision, latence p95 et coût par tâche réussie.
D’abord : faut-il vraiment un modèle ?
| Tâche | Généralement mieux sans LLM |
|---|---|
| Analyser des dates, e-mails, ID, formats connus | Parseur, regex, bibliothèque |
| Agrégations, totaux, filtres | SQL |
| Recherches dans des données de référence | Jointure / dictionnaire |
| Règles métier fixes | Règles dans le code |
| Calcul exact | Code |
| Conversion de format (CSV → Parquet, JSON → table) | Code |
Un LLM est pertinent quand l’entrée est non structurée ou ambiguë, quand les règles sont difficiles à écrire, ou quand la sortie est du langage naturel.
Une conception robuste et courante : du code pour tout ce qui est déterministe, le modèle seulement pour la partie ambiguë.
Critères de comparaison
| Critère | Ce que cela signifie | Comment l’évaluer |
|---|---|---|
| Capacité / taille | Qualité générale sur les tâches complexes | Votre jeu d’évaluation, pas seulement les classements publics |
| Profondeur de raisonnement | Logique en plusieurs étapes, planification, analyse | Les cas difficiles de votre domaine |
| Latence | Temps jusqu’au premier token et jusqu’à la réponse complète | p50 et p95 avec vos tailles de prompt réelles |
| Coût | Prix par token d’entrée/sortie, tokens consommés | Coût par tâche réussie |
| Fenêtre de contexte | Quantité d’entrée par requête | Votre plus grosse requête réelle plus la sortie |
| Sortie structurée | Renvoie de façon fiable un JSON / schéma valide | Taux de validation réussie |
| Utilisation d’outils | Appelle correctement fonctions et API | Taux de bon outil et de bons arguments |
| Multimodal | Images, documents, audio | Vos fichiers réels, y compris les mauvais scans |
| Débit | Requêtes et tokens par minute disponibles | Limites du fournisseur face à votre pointe |
| Fiabilité | Constance, disponibilité, stabilité des versions | Variance entre exécutions ; SLA ; versions figées |
| Traitement des données | Où les données sont traitées et conservées | Vos exigences de sécurité et de conformité |
Arbre de décision
1. Du code, du SQL, des règles ou un parseur peuvent-ils le faire de façon fiable ?
oui → faites-le. Fin.
2. L'entrée est-elle privée, récente ou propre au métier ?
oui → prévoyez d'abord récupération ou outils (tout modèle en aura besoin).
3. Est-ce de l'extraction, de la classification ou une transformation courte ?
oui → commencez par un modèle plus petit + sortie structurée.
4. Faut-il un raisonnement en plusieurs étapes ou un jugement sur une entrée ambiguë ?
oui → testez un modèle plus grand ou de raisonnement ; comparez latence et coût.
5. Le volume est-il élevé ?
oui → privilégiez le modèle le moins cher qui passe ; envisagez le batch.
6. Est-ce interactif ?
oui → vérifiez la latence p95 ; envisagez le streaming et des modèles plus petits.
7. La sortie doit-elle être exacte ?
oui → validation de schéma, contrôles déterministes, escalade en cas d'échec.
Code / commandes
1. Construire d’abord un jeu d’évaluation
- 50 à 200 cas réels et représentatifs pour commencer, y compris des cas difficiles et limites
- la sortie attendue pour chaque cas, ou une règle de notation
- aucun secret ; masquez ou synthétisez les valeurs sensibles
{"id": "case-017", "input": "Facture INV-2291 payée deux fois le 2026-09-03", "expected": {"label": "billing_issue"}}
Sans cela, le choix du modèle reste une opinion.
2. Noter les candidats sur les mêmes cas
import statistics
import time
def evaluate(call_model, model: str, cases: list[dict], is_correct) -> dict:
"""Exécute un modèle candidat sur un jeu d'évaluation étiqueté."""
latencies, correct, cost = [], 0, 0.0
for case in cases:
started = time.monotonic()
result = call_model(model, case["input"]) # votre wrapper : renvoie {"output": ..., "cost": ...}
latencies.append(time.monotonic() - started)
cost += result["cost"]
correct += bool(is_correct(result["output"], case["expected"]))
return {
"model": model,
"accuracy": correct / len(cases),
"p50_s": statistics.median(latencies),
"p95_s": statistics.quantiles(latencies, n=20)[18],
"cost_per_correct": cost / correct if correct else float("inf"),
}
Exécutez chaque candidat plusieurs fois : les sorties peuvent varier d’une exécution à l’autre.
3. Comparer sur le coût par tâche réussie
cost_per_successful_task = coût total (nouvelles tentatives et escalades comprises)
/ tâches qui passent la validation
Un modèle moins cher avec un faible taux de réussite peut coûter plus par tâche réussie qu’un modèle plus cher.
| Modèle | Précision | Latence p95 | Coût par bonne réponse |
|---|---|---|---|
| Petit | mesurée | mesurée | mesuré |
| Intermédiaire | mesurée | mesurée | mesuré |
| Grand / raisonnement | mesurée | mesurée | mesuré |
Choisissez la ligne la moins chère qui atteint les objectifs de qualité et de latence.
4. Exiger une sortie structurée et la valider
import json
LABELS = {"billing_issue", "access_issue", "data_issue", "other"}
def parse_label(raw: str) -> str | None:
"""Renvoie une étiquette valide, ou None pour que l'appelant relance ou escalade."""
try:
data = json.loads(raw)
except json.JSONDecodeError:
return None
label = data.get("label") if isinstance(data, dict) else None
return label if label in LABELS else None
Utilisez la fonction de sortie structurée ou de schéma JSON du fournisseur quand elle existe. Validez quand même.
5. Cascade : petit modèle d’abord, escalade en cas d’échec
def classify(text: str, call_model) -> str:
for model in ("small-model", "large-model"):
label = parse_label(call_model(model, text)["output"])
if label is not None:
return label
return "needs_review" # file de revue humaine, pas une supposition
Suivez le taux d’escalade. Si la plupart des cas escaladent, commencez par le modèle plus grand.
6. Ajouter récupération ou outils pour les données privées et récentes
- L’entraînement du modèle n’inclut pas vos tables, l’exécution de pipeline d’hier ni vos définitions internes.
- Récupérez des documents, exécutez une requête approuvée ou appelez une API, puis passez le résultat en contexte.
- Choisissez le modèle pour sa capacité à utiliser le contexte fourni, pas pour ce qu’il pourrait avoir mémorisé.
La récupération peut améliorer l’ancrage dans les données, mais ne garantit pas l’exactitude : des documents mauvais ou manquants donnent toujours de mauvaises réponses.
7. Entrées multimodales
- PDF scannés, captures d’écran, graphiques : testez un modèle multimodal sur vos fichiers réels, y compris de mauvaise qualité.
- Alternative : OCR ou parseur de documents d’abord, puis un modèle texte. Souvent moins cher et plus facile à déboguer.
- Les modèles d’embedding servent à la recherche et à la similarité, pas à générer des réponses.
8. Vérifier le débit et les limites
peak_tokens_per_minute = peak_requests_per_minute × average_tokens_per_request
Comparez avec les limites de requêtes et de tokens de chaque candidat. Un modèle qui respecte le budget mais pas le débit échoue quand même en production.
9. La taille de la fenêtre de contexte ne garantit pas la qualité
- Une fenêtre plus grande permet d’envoyer plus, pas forcément mieux.
- Les entrées longues coûtent plus et sont plus lentes.
- Les modèles peuvent exploiter inégalement l’information dans des entrées très longues. Testez avec vos tailles de documents réelles.
10. Figer les versions et réévaluer à chaque changement
- Utilisez des versions de modèle explicites quand le fournisseur le permet.
- Relancez le jeu d’évaluation avant de changer de version ou de fournisseur.
- Gardez le jeu d’évaluation sous contrôle de version, à côté des prompts.
Interpréter le résultat
| Résultat de l’évaluation | Décision |
|---|---|
| Le petit modèle atteint qualité et latence | Utilisez-le ; ajoutez une escalade pour les échecs |
| Le petit modèle échoue seulement sur les cas difficiles | Cascade : petit d’abord, puis escalade |
| Tous les modèles échouent sur les mêmes cas | Corrigez d’abord l’entrée, le contexte ou la définition de la tâche |
| Le grand modèle passe mais trop lentement | Modèle plus petit + meilleur contexte, streaming ou traitement asynchrone |
| La qualité varie entre exécutions | Paramètres moins aléatoires, schéma de sortie plus strict, validation |
| Le code ou le SQL résout la plupart des cas | Utilisez le code ; n’envoyez que le reste à un modèle |
Points à vérifier
- La précision sur les cas difficiles, pas seulement la précision globale.
- La latence p95 avec des tailles de prompt réelles.
- Le taux de validation des sorties structurées.
- Les taux d’escalade et de nouvelles tentatives.
- Le coût par tâche réussie.
- Les conditions de résidence et de conservation des données.
- Le comportement après une mise à jour de version du modèle.
Erreurs fréquentes
1. Utiliser un LLM pour un travail déterministe
Analyser une date ou sommer une colonne avec un modèle est plus lent, plus cher et moins fiable que du code.
2. Choisir d’après les seuls classements publics
Les benchmarks généraux ne mesurent ni vos schémas, ni vos documents, ni vos cas limites.
3. Prendre par défaut le plus gros modèle
Il peut être inutile pour des tâches simples, et il est généralement plus lent et plus cher.
4. Prendre par défaut le modèle le moins cher
Nouvelles tentatives, escalades et mauvaises réponses peuvent en faire l’option la plus coûteuse.
5. Attendre du modèle qu’il connaisse vos données privées
Utilisez la récupération ou des outils ; ne comptez pas sur ce que le modèle pourrait avoir retenu.
6. Faire confiance à la sortie sans validation
Même les modèles performants renvoient parfois une sortie invalide ou plausible mais fausse.
7. N’évaluer qu’une fois
Les sorties varient entre exécutions et entre versions de modèle.
Notes de production
- Gardez le nom et la version du modèle dans la configuration, pas éparpillés dans le code.
- Journalisez la version du modèle avec chaque requête.
- Encapsulez les appels au fournisseur derrière une seule interface pour pouvoir changer de modèle et comparer.
- Gardez le jeu d’évaluation et le code de notation sous contrôle de version.
- Prévoyez un repli (autre modèle, file de revue humaine ou erreur claire) en cas d’indisponibilité du fournisseur.
- Examinez les conditions de traitement et de conservation des données avant d’envoyer des données métier à un modèle hébergé.
Liste de contrôle
- Les parties déterministes sont traitées par du code, du SQL ou des règles.
- Un jeu d’évaluation avec des cas difficiles existe.
- Les candidats sont comparés sur la précision, la latence p95 et le coût par tâche réussie.
- La sortie structurée est validée.
- Les échecs sont escaladés ou envoyés en revue, pas devinés.
- Les données privées arrivent au modèle par récupération ou outils.
- Le débit respecte les limites du fournisseur en pointe.
- Les versions de modèle sont figées et réévaluées à chaque changement.
Ce contenu vous a-t-il été utile ?
Que pourrions-nous améliorer ?
Merci — cela m’aide à améliorer Javi Builds.
Restez au courant
Recevez uniquement les nouvelles de Javi Builds qui vous intéressent.
Consultez votre boîte de réception
Je vous ai envoyé un lien de confirmation. Votre abonnement sera actif après confirmation.