Comment rendre les sorties des LLM prévisibles grâce à la validation Pydantic

Article original : How to Keep LLM Outputs Predictable Using Pydantic Validation

Les grands modèles de langage (LLM) sont puissants, mais ils peuvent aussi être imprévisibles.

Ils peuvent générer de longues explications alors que vous attendez un court résumé, ignorer des champs dans une sortie JSON, ou changer complètement de format d'une requête à l'autre.

Lorsque vous construisez une application d'IA qui dépend de réponses structurées, ces petites erreurs peuvent causer de grandes défaillances.

C'est là que Pydantic intervient.

Pydantic vous permet de définir des formes de données exactes pour les entrées et les sorties de votre système d'IA. En l'utilisant pour valider les réponses du modèle, vous pouvez détecter les incohérences, en corriger certaines automatiquement et rendre l'ensemble de votre workflow LLM beaucoup plus fiable.

Cet article explique comment utiliser Pydantic pour maintenir la prévisibilité des sorties de votre modèle de langage, même lorsque le modèle lui-même ne l'est pas.

Ce que nous allons aborder :

• Le problème des sorties de LLM imprévisibles

• Qu'est-ce que Pydantic

• Validation des réponses du modèle

• Comment Pydantic sécurise les applications d'IA

• Utiliser Pydantic pour imposer une structure aux réponses de l'IA

• Ajouter la validation Pydantic dans les Frameworks de LLM

• Cas d'utilisation concrets

• Conclusion

Le problème des sorties de LLM imprévisibles

Imaginez que vous construisez une application d'IA qui génère des résumés d'avis sur des produits. Vous demandez au modèle de renvoyer un JSON structuré avec deux champs : summary et sentiment.

Votre prompt ressemble à ceci :

« Résume cet avis et renvoie un JSON avec les clés ‘summary’ et ‘sentiment’. »

La plupart du temps, cela fonctionne. Mais parfois, le modèle ajoute du texte supplémentaire autour du JSON, oublie une clé ou renvoie le mauvais type de données.

Par exemple, {"summary": "Bonne qualité de fabrication", "sentiment": "positive"} est parfait. Mais parfois, vous obtenez Bien sûr, voici le résultat ! {"summary": "Trop cher mais fonctionne bien"} ou {"summary": "Bel appareil photo", "sentiment": 5}.

Vous pourriez essayer de corriger cela avec du parsing de chaînes de caractères (string parsing), mais cela devient vite complexe. Au lieu de cela, vous pouvez définir un schéma strict à l'aide de Pydantic et vous assurer que seules les réponses valides sont acceptées.

Qu'est-ce que Pydantic ?

Pydantic est une bibliothèque Python qui vous permet de définir des modèles de données à l'aide de classes simples. Elle valide automatiquement les types et les structures de données lorsque vous créez une instance de modèle.

Si quelque chose est manquant ou incorrect, Pydantic lève une erreur, vous aidant à identifier les problèmes rapidement.

Un exemple de base ressemble à ceci :

from pydantic import BaseModel

class ReviewSummary(BaseModel):
    summary: str
    sentiment: str
data = {"summary": "Nice screen", "sentiment": "positive"}
result = ReviewSummary(**data)
print(result)

Si vous essayez de passer un entier là où une chaîne de caractères est attendue, Pydantic lève une erreur de validation claire. C'est exactement ce mécanisme que nous pouvons utiliser pour valider les sorties des LLM.

Validation des réponses du modèle

Connectons cette idée à une réponse réelle de LLM. Supposons que vous utilisiez l'API d'OpenAI. Vous pouvez demander au modèle de renvoyer des données structurées, puis les valider à l'aide de Pydantic, comme ceci :

import json
from pydantic import BaseModel, ValidationError
from openai import OpenAI

client = OpenAI()
class ReviewSummary(BaseModel):
    summary: str
    sentiment: str
prompt = "Summarize this review and return JSON with keys: summary, sentiment.\n\nReview: The phone is fast but battery drains quickly."
response = client.responses.create(
    model="gpt-4o-mini",
    input=prompt
)
raw_text = response.output_text
try:
    parsed = json.loads(raw_text)
    validated = ReviewSummary(**parsed)
    print(validated)
except (json.JSONDecodeError, ValidationError) as e:
    print("Validation failed:", e)

Ici, la réponse du modèle passe par deux étapes. D'abord, elle est analysée du texte vers le JSON. Ensuite, Pydantic vérifie si elle correspond au schéma attendu. Si un élément manque, une erreur est générée. Vous pouvez l'intercepter et décider de la manière de la gérer.

Comment Pydantic sécurise les applications d'IA

Les LLM sont probabilistes. Même avec des prompts parfaits, vous ne pouvez jamais garantir qu'ils suivront votre structure à chaque fois.

L'utilisation de Pydantic ajoute une couche déterministe par-dessus cette incertitude. Il agit comme un contrat entre votre application et le modèle. Chaque réponse doit respecter ce contrat. Si ce n'est pas le cas, votre système peut immédiatement le détecter, le rejeter ou réessayer avec un prompt plus clair.

C'est particulièrement important pour les applications d'IA de niveau production où des réponses imprévisibles peuvent casser les flux utilisateurs, faire planter les API ou corrompre les données dans une base de données.

En validant les sorties, vous obtenez trois grands avantages : des formats de données prévisibles, une gestion claire des erreurs et un traitement en aval plus sûr.

Utiliser Pydantic pour imposer une structure aux réponses de l'IA

Vous pouvez également utiliser Pydantic dans des workflows plus complexes. Disons que votre modèle génère des réponses structurées pour un chatbot qui nécessite plusieurs champs : une réponse, un score de confiance et des questions de suivi suggérées.

from typing import List
from pydantic import BaseModel, Field

class ChatResponse(BaseModel):
    answer: str
    confidence: float = Field(ge=0, le=1)
    follow_ups: List[str]

Maintenant, votre modèle doit renvoyer quelque chose comme :

{
  "answer": "You can enable dark mode in settings.",
  "confidence": 0.92,
  "follow_ups": ["How to change wallpaper?", "Can I set auto dark mode?"]
}

Si le modèle produit des données invalides, comme une clé manquante ou un score de confiance négatif, Pydantic le signale instantanément.

Vous pouvez alors enregistrer l'erreur, réessayer avec un message système ou remplacer les données manquantes par des valeurs par défaut.

Ajouter la validation Pydantic dans les Frameworks de LLM

Des Frameworks comme LangChain et FastAPI fonctionnent parfaitement avec Pydantic.

Dans LangChain, vous pouvez définir des schémas d'outils (tools) ou d'agents à l'aide de classes Pydantic pour garantir que toutes les interactions entre le modèle et les outils sont cohérentes.

Par exemple :

from langchain.tools import StructuredTool

tool = StructuredTool.from_function(
    func=lambda x: x * 2,
    args_schema=PydanticModel,
    description="Doubles the input number"
)

Dans FastAPI, chaque point de terminaison (endpoint) peut accepter et renvoyer des modèles Pydantic. Cela le rend parfait pour les API d'IA où les réponses du modèle sont validées automatiquement avant d'être envoyées aux clients.

Améliorer la fiabilité des LLM grâce au feedback

Lorsque vous commencez à valider les sorties, vous remarquerez rapidement des schémas dans la manière dont votre LLM échoue. Parfois, il ajoute des commentaires superflus, parfois il confond les noms de clés.

Au lieu de corriger manuellement ces erreurs à chaque fois, vous pouvez réinjecter ces informations dans vos prompts ou vos données de fine-tuning.

Par exemple, si le modèle continue d'écrire sentiments au lieu de sentiment, ajoutez une instruction de correction à votre prompt système. Avec le temps, les erreurs de validation diminueront et le modèle apprendra à se conformer à votre structure de manière plus cohérente.

Cas d'utilisation concrets

Les développeurs utilisent la validation Pydantic dans de nombreux systèmes d'IA.

Dans les chatbots d'IA, elle garantit un formatage cohérent des messages et des scores de confiance. Dans les systèmes de résumé, elle valide que chaque résumé inclut des champs clés comme le titre, le ton ou les mots-clés. Dans les API pilotées par l'IA, elle agit comme un garde-fou qui empêche les données invalides de se propager en aval.

C'est particulièrement utile dans les pipelines de génération augmentée par récupération (RAG), où les sorties structurées telles que les scores de documents ou les entités sont cruciales pour maintenir un contexte précis.

Conclusion

Pydantic apporte de la structure au chaos des sorties de LLM. Il transforme la génération de texte imprévisible en données prévisibles et vérifiées par schéma. En validant les réponses du modèle, vous rendez vos workflows d'IA fiables, déboguables et prêts pour la production.

La combinaison de la flexibilité des LLM et du typage strict de Pydantic est puissante. Vous bénéficiez de la créativité des modèles de langage avec le contrôle de la validation des données.

Lorsque chaque sortie suit un schéma, votre IA devient non seulement intelligente, mais aussi fiable.

J'espère que vous avez apprécié cet article. Inscrivez-vous à ma newsletter gratuite TuringTalks.ai pour plus de tutoriels pratiques sur l'IA. Vous pouvez également visiter mon site web.