L'IA qui lit comme un humain : comment un système RAG peut répondre sans se tromper ?

UNE MACHINE QUI SE CORRIGE TOUTE SEULE

Imaginez un élève qui écrit une dissertation. Au lieu de rendre son brouillon directement, il le relit, repère les parties manquantes ou mal expliquées, et demande à son professeur : « Est-ce que j’ai bien tout compris ? » avant de rendre le travail final. C’est exactement ce que fait un système RAG avancé avec les documents qu’il analyse. Dans cette série d’articles dédiée à l’intelligence documentaire en entreprise, les chercheurs ont construit un mécanisme où l’IA ne se contente pas de répondre à une question : elle évalue elle-même la qualité de sa réponse et relance une Recherche si nécessaire.

Le cœur de cette innovation repose sur trois couches : la compréhension de la question, l’analyse du document, et une boucle de rétroaction qui décide quand s’arrêter. Chaque couche fonctionne comme un expert indépendant : le premier expert lit la question, le deuxième analyse le PDF, et le troisième vérifie que la réponse est complète. Si quelque chose cloche, la machine relance le processus automatiquement.

LA RECETTE D’UNE BOUCLE DE CORRECTION PARFAITE

Pour comprendre comment fonctionne cette boucle, prenons un exemple concret. Imaginons que vous posiez à l’IA la question suivante : « Quelles sont les techniques de régularisation utilisées dans l’article sur le Transformer, et où montrent-elles leur impact sur le score BLEU ? » L’IA va suivre plusieurs étapes précises :

1. Comprendre la question : L’IA identifie les mots-clés (« régularisation », « Transformer », « BLEU ») et détermine l’intention (« lister des éléments »). Elle repère aussi des indices structurels comme « Table 3 » ou « Section 5.4 ».

2. Analyser le document : L’IA parcourt le PDF pour repérer les passages pertinents. Elle vérifie s’il y a une table des matières utilisable, si le document est structuré ou scanné, et quelles parties contiennent les informations demandées.

3. Décider des outils à activer : En fonction de la question et du document, l’IA active les bons outils. Par exemple, si la question demande une liste, elle active la recherche par mots-clés. Si la réponse pointe vers une autre section, elle active la résolution à deux sauts. Si le document a une table des matières, elle l’utilise en priorité.

4. Lancer la recherche et la génération : L’IA effectue une première recherche avec les mots-clés identifiés, puis génère une réponse. Mais au lieu de s’arrêter là, elle relit sa propre réponse pour vérifier qu’elle est complète et correcte.

5. Critiquer la réponse : L’IA utilise des indicateurs de qualité pour évaluer sa réponse. Par exemple, elle vérifie si le contexte est complet, si de nouveaux mots-clés ont été découverts, ou si la structure du document a été correctement analysée. Si quelque chose manque, elle relance une recherche avec des mots-clés plus précis ou une nouvelle analyse du document.

6. Arrêter la boucle : La boucle s’arrête quand l’IA estime que sa réponse est complète et correcte, ou quand elle a atteint le nombre maximal d’itérations (généralement 4).

LE CODE QUI FAIT TOUT FONCTIONNER

Derrière cette boucle de correction se cache un code Python bien organisé. Voici les principales fonctions qui orchestrent ce mécanisme :

def pdfqaloop(pdfpath, question, *, registry=None, maxiterations=4):
    registry = registry or PatternRegistry.default()
    # 1. Comprendre la question
    parsed = registry.parse_question(question)
    # 2. Analyser rapidement le document
    linedf, pagedf, tocdf = registry.parselayer1(pdf_path)
    # 3. Détecter le type de document
    docprofile = registry.detectdocumenttype(pdfpath)
    # 4. Décider quels outils activer
    activations = decidepipelinepatterns(parsed, doc_profile)
    # 5-7. Lancer la recherche et la génération dans une boucle bornée
    state = State(parsed=parsed, linedf=line_df,
                   pagedf=pagedf, tocdf=tocdf)
    outcome = iteratewithbound(
        initial_state=state,
        runpass=lambda s: onepass(s, registry, activations, pdfpath),
        issatisfactory=lambda a: not needs_iteration(a),
        adjust=lambda s, a: adjuststate(s, a, registry,
                                          activations, pdf_path),
        record=buildrecord,
        maxiterations=maxiterations,
    )
    return CompositeOutput(answer=outcome.result, activations=activations,
                           history=outcome.history,
                           exhausted=outcome.exhausted)

Cette fonction, pdfqaloop, est le chef d’orchestre de tout le système. Elle prend en entrée un fichier PDF et une question, puis elle exécute les étapes suivantes :

• parse_question : Comprend la question en identifiant les mots-clés et l’intention.
• parse_layer1 : Effectue une première analyse rapide du document pour repérer les lignes, les pages et la table des matières.
• detectdocumenttype : Détermine si le document est structuré, scanné, ou s’il contient une table des matières utilisable.
• decidepipelinepatterns : Active les outils adaptés en fonction de la question et du document.
• iteratewithbound : Lance la boucle de recherche et de génération, en relançant le processus si nécessaire.

LE DISPATCHER : LE CERVEAU QUI CHOISIT LES OUTILS

Le dispatcher est la pièce maîtresse de ce système. C’est lui qui décide quels outils activer en fonction de la question et du document. Voici comment il fonctionne :

def decidepipelinepatterns(
    parsed: ParsedQuestion,
    doc_profile: DocumentProfile,
) -> Activations:
    activations = dict(DEFAULT_ACTIVATIONS)

    # Activer la recherche par table des matières si le document en a une
    if docprofile.hasusable_toc:
        activations["toc_retrieval"] = True

    # Activer la recherche par similarité (embeddings) pour les questions larges
    if parsed.intent in ("openscoped", "opencorpus_wide"):
        activations["dense_retrieval"] = True

    # Activer la résolution à deux sauts si la question pointe vers une autre section
    if parsed.retrieval.sectionhint or parsed.retrieval.layouthint:
        activations["twohopreferences"] = True
    if parsed.intent in ("sectionretrieval", "openscoped"):
        activations["twohopreferences"] = True

    # Activer l'agrégation de liste si la question demande une liste
    if parsed.intent == "listing":
        activations["listing_aggregation"] = True

    return activations

Ce dispatcher utilise des règles simples pour activer les bons outils :

• toc_retrieval : Si le document a une table des matières, l’IA l’utilise en priorité pour trouver les passages pertinents.
• dense_retrieval : Si la question est large (par exemple, « Quelles sont toutes les techniques de régularisation ? »), l’IA utilise une recherche par similarité pour trouver les passages les plus pertinents.
• twohopreferences : Si la question pointe vers une autre section (par exemple, « Voir le Tableau 3 »), l’IA active une recherche à deux sauts pour suivre la référence.
• listing_aggregation : Si la question demande une liste (par exemple, « Listez les obligations du vendeur »), l’IA active une agrégation pour rassembler toutes les informations pertinentes.

LA BOUCLE BORNÉE : QUAND S’ARRÊTER ?

La boucle de rétroaction est ce qui rend ce système si puissant. Contrairement à un système RAG classique qui s’arrête après une seule recherche, ce système relance le processus tant que la réponse n’est pas complète ou correcte. Voici comment fonctionne cette boucle :

def iteratewithbound(
    *,
    initial_state: TState,
    run_pass: Callable[[TState], TResult],
    is_satisfactory: Callable[[TResult], bool],
    adjust: Callable[[TState, TResult], TState],
    record: Callable[[int, TResult, TState, TResult | None], IterationRecord],
    max_iterations: int = 3,
) -> IterationOutcome[TState, TResult]:
    """Exécuter une boucle de pipeline avec rétroaction bornée."""
    state = initial_state
    history: list[IterationRecord] = []
    result = run_pass(state)
    previous_result: TResult | None = None
    if is_satisfactory(result):
        history.append(record(0, result, state, previous_result))
        return IterationOutcome(result=result, history=history, exhausted=False)
    for i in range(1, max_iterations):
        next_state = adjust(state, result)
        history.append(record(i, result, nextstate, previousresult))
        previous_result = result
        state = next_state
        result = run_pass(state)
        if is_satisfactory(result):
            return IterationOutcome(result=result, history=history, exhausted=False)
    return IterationOutcome(result=result, history=history, exhausted=True)

Cette fonction prend en entrée :

• initial_state : L’état initial du système (question, document analysé, etc.).
• run_pass : Une fonction qui exécute une passe de recherche et de génération.
• is_satisfactory : Une fonction qui vérifie si la réponse est complète et correcte.
• adjust : Une fonction qui ajuste l’état du système en fonction des résultats précédents.
• record : Une fonction qui enregistre l’historique des itérations.
• max_iterations : Le nombre maximal d’itérations autorisées (par défaut, 3).

La boucle fonctionne ainsi :

1. L’IA effectue une première passe de recherche et de génération.
2. Si la réponse est satisfaisante, la boucle s’arrête.
3. Sinon, l’IA ajuste son état (par exemple, en ajoutant de nouveaux mots-clés ou en relançant une analyse du document).
4. L’IA effectue une nouvelle passe de recherche et de génération.
5. Si la réponse est satisfaisante, la boucle s’arrête. Sinon, le processus recommence jusqu’à ce que le nombre maximal d’itérations soit atteint.

LES INDICATEURS QUI DÉCLENCHENT UNE NOUVELLE RECHERCHE

Pour savoir quand relancer une recherche, l’IA utilise plusieurs indicateurs :

def shouldcontinue(history: list, current: ResultProto,
                    confidencedropthreshold: float = 0.1) -> bool:
    """Décider si la boucle doit continuer ou s'arrêter.

    Trois raisons d'arrêter, par ordre de priorité :
      1. Les candidats sont stables (identiques à la passe précédente) : rien de nouveau ne sera trouvé.
      2. Les mots-clés suggérés sont stables : l'IA répète les mêmes recherches.
      3. La confiance diminue au-delà du seuil : la boucle empire les choses.
    """
    if history:
        prev = history[-1]
        if getattr(prev, "candidates", None) == current.candidates:
            return False
        if getattr(prev, "suggestedkeywords", None) == current.suggestedkeywords:
            return False
        prev_conf = getattr(prev, "confidence", None)
        if prev_conf is not None and current.confidence < prev_conf - confidence_drop_threshold:
            return False
    return current.needs_iteration()

Les trois principaux indicateurs sont :

• Stabilité des candidats : Si les passages trouvés sont identiques à ceux de la passe précédente, l’IA arrête la boucle car elle ne trouvera rien de nouveau.
• Stabilité des mots-clés : Si les mots-clés suggérés par l’IA sont identiques à ceux de la passe précédente, l’IA arrête la boucle car elle répète les mêmes recherches.
• Diminution de la confiance : Si la confiance de l’IA dans sa réponse diminue de plus de 0,1 entre deux passes, l’IA arrête la boucle car elle risque d’empirer les choses.

UN EXEMPLE CONCRET : LA QUESTION SUR LES TECHNIQUES DE RÉGULARISATION

Prenons l’exemple de la question : « Quelles sont les techniques de régularisation utilisées dans l’article sur le Transformer, et où montrent-elles leur impact sur le score BLEU ? » Voici comment l’IA va procéder :

1. Comprendre la question : L’IA identifie les mots-clés (« régularisation », « Transformer », « BLEU ») et l’intention (« lister des éléments »). Elle repère aussi des indices structurels comme « Table 3 » et « Section 5.4 ».

2. Analyser le document : L’IA parcourt le PDF pour repérer les passages pertinents. Elle détecte que le document a une table des matières utilisable et qu’il est structuré en texte natif.

3. Activer les outils : Le dispatcher active les outils suivants :

• toc_retrieval : Utilisation de la table des matières pour trouver la Section 5.4.
• keyword_retrieval : Recherche par mots-clés pour trouver les passages contenant « régularisation », « dropout », et « label smoothing ».
• twohopreferences : Résolution à deux sauts pour suivre la référence vers le Tableau 3.
• listing_aggregation : Agrégation des résultats pour lister les techniques de régularisation.
• iterative_feedback : Boucle de rétroaction pour vérifier que la réponse est complète.

4. Première passe : L’IA effectue une première recherche et génère une réponse. Elle découvre que trois techniques de régularisation sont utilisées : Residual Dropout, Attention Dropout, et Label Smoothing. Elle mentionne aussi que ces techniques sont validées dans le Tableau 3.

5. Critique de la réponse : L’IA vérifie que sa réponse est complète. Elle constate que la référence vers le Tableau 3 est toujours en attente. Elle relance donc une recherche pour trouver le Tableau 3.

6. Deuxième passe : L’IA relance une recherche pour trouver le Tableau 3. Elle découvre que le Tableau 3 montre l’impact des techniques de régularisation sur le score BLEU. Elle met à jour sa réponse avec ces informations.

7. Critique finale : L’IA vérifie que sa réponse est maintenant complète. Elle constate que tous les éléments sont présents : les trois techniques de régularisation, leurs paramètres, et leur impact sur le score BLEU. La boucle s’arrête.

POURQUOI CE SYSTÈME EST RÉVOLUTIONNAIRE ?

Ce système change radicalement la façon dont les IA traitent les documents. Voici pourquoi :

1. Plus de réponses incomplètes ou erronées : Grâce à la boucle de rétroaction, l’IA vérifie elle-même la qualité de sa réponse et relance une recherche si nécessaire. Cela réduit considérablement les erreurs et les omissions.

2. Une architecture modulaire et maintenable : Le système est divisé en plusieurs couches (compréhension de la question, analyse du document, boucle de rétroaction) qui communiquent entre elles via des objets typés. Chaque couche peut être améliorée indépendamment sans affecter les autres.

3. Un contrôle total sur le processus : Contrairement aux systèmes « agentiques » où l’IA décide elle-même des étapes suivantes, ce système garde le contrôle dans le code. Cela rend le système plus prévisible, auditable, et facile à déboguer.

4. Une adaptabilité à tous les types de documents : Que ce soit un contrat, un article scientifique, ou un rapport technique, le système s’adapte grâce à son dispatcher qui active les bons outils en fonction du document et de la question.

5. Une transparence totale : Grâce à l’historique des itérations, il est possible de suivre chaque étape du processus et de comprendre pourquoi l’IA a pris telle ou telle décision. C’est comme avoir un rapport détaillé de chaque étape de la recherche.

COMMENT CE SYSTÈME S’INTÈGRE DANS UNE ARCHITECTURE PLUS LARGE ?

Ce système est la troisième partie d’une série dédiée à l’intelligence documentaire en entreprise. Voici comment il s’intègre dans l’architecture globale :

Niveau 1 : La base (Article 1) : Une chaîne simple qui enchaîne les quatre briques (analyse du document, analyse de la question, recherche, génération) en une seule passe avec une recherche par mots-clés. La réponse est retournée directement sans vérification.

Niveau 2 : L’amélioration (Article 9) : Une version enrichie qui garde la même passe unique mais ajoute une analyse relationnelle complète et un routage par table des matières. La réponse est typée et contient des champs de feedback, mais ceux-ci ne sont pas encore utilisés pour relancer une recherche.

Niveau 3 : Le workflow (cet article) : Cette version transforme la passe unique en une étape dans une boucle bornée. Le dispatcher choisit quels outils activer, et la boucle lit les champs de feedback pour décider de relancer une recherche ou non. Le contrôle reste dans le code.

Niveau 4 : Le multi-intent (travail futur) : Une version qui élargit l’entrée : une interface de chat classe l’intention de l’utilisateur (question, traduction, résumé, ou simple salutation) et oriente vers le bon pipeline. Le contrôle reste dans le code.

Niveau 5 : Le système agentique (travail futur) : Une version où le contrôle de la boucle est déplacé vers l’IA elle-même, qui choisit les étapes suivantes. Cet article s’arrête deux niveaux en dessous, où le pipeline reste reproductible et auditable.

LE CODE SOURCE : UN SYSTÈME OUVERT À TOUS

Pour ceux qui veulent explorer ce système par eux-mêmes, les chercheurs ont mis à disposition un notebook compagnon sur GitHub. Ce notebook permet de tester la boucle de rétroaction en direct : vous pouvez poser une question à l’IA, voir les itérations se dérouler, et observer comment l’IA critique sa propre réponse et relance une recherche si nécessaire.

Le notebook est disponible à l’adresse suivante : doc-intel/notebooks-vol1. Il permet de comprendre concrètement comment fonctionne ce système et comment l’adapter à vos propres besoins.

LES LIMITES ET LES DÉFIS À RELEVER

Bien que ce système soit révolutionnaire, il n’est pas parfait. Voici quelques limites et défis à relever :

1. Le nombre d’itérations : La boucle est limitée à 4 itérations maximum. Dans la plupart des cas, cela suffit, mais pour des questions très complexes, cela peut ne pas être suffisant.

2. La qualité des indicateurs : Les indicateurs utilisés pour décider si la boucle doit continuer (stabilité des candidats, stabilité des mots-clés, diminution de la confiance) ne sont pas parfaits. Ils peuvent parfois conduire à des arrêts prématurés ou à des boucles infinies.

3. La complexité du code : Bien que le système soit modulaire, le code reste complexe et nécessite une bonne compréhension de Python et des concepts d’IA pour être modifié ou étendu.

4. La performance : Chaque itération ajoute du temps de calcul. Pour des questions simples, cela peut sembler excessif, mais pour des questions complexes, cela est nécessaire pour garantir la qualité de la réponse.

QUEL AVENIR POUR CE SYSTÈME ?

Ce système ouvre la voie à de nombreuses améliorations et extensions. Voici quelques pistes pour l’avenir :

1. Améliorer les indicateurs : Développer des indicateurs plus précis pour décider quand arrêter la boucle, en utilisant par exemple des modèles de confiance plus avancés.

2. Étendre le nombre d’itérations : Permettre plus de 4 itérations pour les questions très complexes, tout en gardant un contrôle strict sur les performances.

3. Intégrer des modèles de langage plus avancés : Utiliser des modèles plus puissants pour améliorer la qualité des réponses et réduire le nombre d’itérations nécessaires.

4. Développer des interfaces plus intuitives : Créer des interfaces qui permettent aux utilisateurs non techniques de configurer et d’utiliser ce système facilement.

5. Étendre à d’autres types de documents : Adapter ce système à d’autres formats de documents (images, vidéos, présentations) pour élargir son champ d’application.

6. Intégrer des mécanismes d’apprentissage : Permettre au système d’apprendre des erreurs passées pour améliorer ses performances futures.

EN CONCLUSION : UN PAS DE GÉANT POUR L’IA DOCUMENTAIRE

Ce système représente une avancée majeure dans le domaine de l’intelligence artificielle documentaire. En permettant à l’IA de critiquer ses propres réponses et de relancer une recherche si nécessaire, il réduit considérablement les erreurs et les omissions, tout en offrant une transparence et une audibilité totales. Contrairement aux systèmes « agentiques » où l’IA décide elle-même des étapes suivantes, ce système garde le contrôle dans le code, ce qui le rend plus prévisible et plus facile à déboguer.

Avec ce système, l’IA ne se contente plus de répondre à une question : elle garantit que sa réponse est complète, correcte, et adaptée au document. C’est un pas de géant vers des systèmes d’IA plus fiables et plus transparents, capables de rivaliser avec la rigueur d’un humain.

Pour les entreprises, cela signifie des réponses plus précises, des processus plus fiables, et une meilleure confiance dans les résultats générés par l’IA. Pour les développeurs, cela ouvre la voie à de nouvelles architectures plus modulaires et plus maintenables. Pour les utilisateurs finaux, cela signifie des réponses plus fiables et plus complètes, sans avoir à vérifier manuellement chaque détail.

Ce système n’est qu’un début. Avec les améliorations futures, il pourrait devenir encore plus puissant et plus précis, ouvrant la voie à une nouvelle génération d’IA documentaire.