AI Prompt Engineering · Leçon

Validateurs de schémas et de règles

Faire respecter les contraintes.

Validateurs de schémas et de règles est une leçon AI Prompt Engineering gratuite sur CoddyKit. Ceci est la leçon 3 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage AI Prompt Engineering, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours AI Prompt Engineering comprend 4 leçons au total.

Les validateurs imposent le contrat

Un validateur est un garde-fou qui vérifie la sortie par rapport à une spécification explicite : un schéma JSON, un ensemble de règles métier, ou les deux. Contrairement à un classificateur de modération, un validateur est déterministe et entièrement auditable ; une même entrée produit toujours le même verdict.

Couche de validation du schéma

Le premier validateur confirme que la sortie respecte le contrat structurel. Recueillez toutes les erreurs, et pas seulement la première, afin que les retours de réparation soient complets.

import jsonschema
def schema_errors(obj, schema):
    v = jsonschema.Draft202012Validator(schema)
    return [f"{list(e.path) or 'root'}: {e.message}"
            for e in v.iter_errors(obj)]

Au-delà du schéma : les règles métier

Les schémas ne peuvent pas tout exprimer. Un schéma peut indiquer que discount est un nombre, mais pas qu’il ne doit pas dépasser le sous-total. Les validateurs de règles encodent ces invariants inter-champs et ces invariants du domaine dans le code.

RULES = [
  ('discount_le_subtotal', lambda o: o['discount'] <= o['subtotal']),
  ('total_consistent', lambda o: o['total'] == o['subtotal'] - o['discount']),
  ('currency_supported', lambda o: o['currency'] in SUPPORTED)
]
def rule_errors(o):
    return [name for name, fn in RULES if not fn(o)]

Les modèles typés comme validateurs

Une bibliothèque de modèles typés (par exemple Pydantic) sert à la fois de générateur de schémas et de validateur, avec des validateurs personnalisés pour les règles. L’échec de l’analyse est le verdict.

from pydantic import BaseModel, field_validator

class Order(BaseModel):
    subtotal: float
    discount: float
    total: float

    @field_validator('discount')
    @classmethod
    def discount_ok(cls, v, info):
        if v < 0:
            raise ValueError('discount must be non-negative')
        return v

Validation de l’ancrage et des citations

Pour les sorties RAG, vérifiez que les affirmations sont étayées par le contexte fourni. Exigez du modèle qu’il cite les identifiants des sources, puis vérifiez que chaque identifiant cité existe et que les passages cités apparaissent réellement dans la source. Rejetez les réponses qui citent des sources absentes ou fabriquées.

def citations_valid(answer, sources):
    for cite in answer['citations']:
        if cite['source_id'] not in sources:
            return False
        if cite['quote'] not in sources[cite['source_id']]:
            return False
    return True

Vérifications référentielles et intersystèmes

Certaines règles nécessitent des consultations externes : l’identifiant de commande référencé existe-t-il, le produit est-il en stock, la date se situe-t-elle dans une période valide ? Ces validateurs interrogent vos systèmes. Gardez-les rapides (mise en cache, traitement par lots), car ils se trouvent sur le chemin de réponse.

def order_exists(o):
    return db.exists('SELECT 1 FROM orders WHERE id = %s', o['order_id'])

Verdicts marqués par niveau de gravité

Toutes les violations ne se valent pas. Attribuez à chaque règle un niveau de gravité afin que la chaîne de traitement puisse choisir la bonne action : bloquez strictement les violations critiques, régénérez en cas de problèmes de qualité et laissez passer avec un avertissement les problèmes mineurs.

RULE_SEVERITY = {
  'discount_le_subtotal': 'critical',
  'total_consistent': 'critical',
  'tone_professional': 'warning'
}

Composer les validateurs dans l’ordre

Exécutez les validateurs du moins coûteux au plus coûteux et arrêtez-vous dès les échecs bloquants : le schéma, puis les règles en mémoire, puis les consultations externes et enfin les vérifications effectuées par un modèle-évaluateur. Cela réduit le coût sur le chemin courant de rejet.

def validate_all(obj):
    errs = schema_errors(obj, SCHEMA)
    if errs: return Reject(errs, 'critical')
    errs = rule_errors(obj)
    if errs: return Reject(errs, max_severity(errs))
    if not order_exists(obj): return Reject(['order_id'], 'critical')
    return Accept()

Les validateurs alimentent les retours de réparation

La valeur d’un validateur décuple lorsque ses messages alimentent la boucle de réparation. Produisez des erreurs exploitables par la machine, indiquant le chemin du champ, la règle qui a échoué et la valeur fautive, afin que le modèle puisse corriger précisément en une seule passe.

{'errors': [
  {'path': 'discount', 'rule': 'discount_le_subtotal',
   'got': 120, 'limit': 100}
]}

Tester les validateurs eux-mêmes

Un validateur défectueux laisse silencieusement passer une mauvaise sortie ou bloque une bonne sortie. Soumettez chaque règle à des essais unitaires avec des cas positifs et négatifs, et ajoutez des essais fondés sur les propriétés pour les invariants numériques. La suite d’essais des validateurs est du code critique pour la production, pas un simple programme.

def test_discount_rule():
    assert rule_errors({'discount':10,'subtotal':100,'total':90}) == []
    assert 'discount_le_subtotal' in rule_errors(
        {'discount':120,'subtotal':100,'total':-20})

Validateurs ou décodage contraint

Le décodage contraint empêche les erreurs structurelles au moment de la génération, mais ne peut pas imposer la sémantique (il ne connaît pas vos règles métier). Les validateurs détectent les violations sémantiques après coup. Utilisez les deux : le décodage pour la forme, les validateurs pour le sens et la boucle de réparation pour réconcilier l’ensemble.

Vérification rapide

Un schéma JSON indique que discount et subtotal sont des nombres. Le modèle renvoie discount 120 avec subtotal 100. Quelle couche devrait détecter cela ?

Récapitulatif

Validateurs de schéma et de règles :

La validation du schéma couvre la structure ; les validateurs de règles couvrent la sémantique.
Les modèles typés génèrent les schémas et valident au même endroit.
Ajoutez des vérifications d’ancrage, de citations et de références pour les flux RAG et les flux de données.
Attribuez un niveau de gravité, composez les validateurs du moins coûteux au plus coûteux et transmettez des erreurs de réparation précises.
Testez les validateurs comme du code critique pour la production.

Ensuite : la validation par auto-évaluation, où le modèle vérifie sa propre sortie.

Questions Fréquemment Posées

La leçon « Validateurs de schémas et de règles » est-elle gratuite ?

Oui — le texte complet de « Validateurs de schémas et de règles » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours AI Prompt Engineering, passe à CoddyKit PRO. Le cours AI Prompt Engineering comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Validateurs de schémas et de règles » ?

Faire respecter les contraintes. Tu pratiques AI Prompt Engineering avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer AI Prompt Engineering ?

Aucune expérience préalable n'est requise. AI Prompt Engineering sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 3 sur 4.

Combien de temps prend la leçon « Validateurs de schémas et de règles » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon AI Prompt Engineering ?

Oui. Chaque leçon AI Prompt Engineering inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

← Retour à AI Prompt Engineering