Parcourir les aide-mémoire · Ingénierie IA pour les données

Technologie: Ingénierie IA pour les donnéesCatégorie: Choix de modèleNiveau: DébutantMis à jour

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
  1. Problème
  2. Réponse rapide
  3. D’abord : faut-il vraiment un modèle ?
  4. Critères de comparaison
  5. Arbre de décision
  6. Code / commandes
  7. 1. Construire d’abord un jeu d’évaluation
  8. 2. Noter les candidats sur les mêmes cas
  9. 3. Comparer sur le coût par tâche réussie
  10. 4. Exiger une sortie structurée et la valider
  11. 5. Cascade : petit modèle d’abord, escalade en cas d’échec
  12. 6. Ajouter récupération ou outils pour les données privées et récentes
  13. 7. Entrées multimodales
  14. 8. Vérifier le débit et les limites
  15. 9. La taille de la fenêtre de contexte ne garantit pas la qualité
  16. 10. Figer les versions et réévaluer à chaque changement
  17. Interpréter le résultat
  18. Points à vérifier
  19. Erreurs fréquentes
  20. 1. Utiliser un LLM pour un travail déterministe
  21. 2. Choisir d’après les seuls classements publics
  22. 3. Prendre par défaut le plus gros modèle
  23. 4. Prendre par défaut le modèle le moins cher
  24. 5. Attendre du modèle qu’il connaisse vos données privées
  25. 6. Faire confiance à la sortie sans validation
  26. 7. N’évaluer qu’une fois
  27. Notes de production
  28. Liste de contrôle
  29. Étape suivante
  30. 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.

Étape suivante

  • Besoin d’estimer le coût du modèle choisi → Coût LLM et budget de tokens.
  • Le modèle a besoin de meilleures instructions pour les tâches de données → Patrons de prompts pour l’ingénierie des données.
  • Le modèle a besoin d’une meilleure entrée, pas d’un plus gros modèle → Ingénierie du contexte pour les LLM.

← Tous les aide-mémoire